1 /* vi:set ts=8 sts=4 sw=4 noet: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 5 * Do ":help uganda" in Vim to read copying and usage conditions. 6 * Do ":help credits" in Vim to see a list of people who contributed. 7 * See README.txt for an overview of the Vim source code. 8 */ 9 /* 10 * Python extensions by Paul Moore. 11 * Changes for Unix by David Leonard. 12 * 13 * This consists of four parts: 14 * 1. Python interpreter main program 15 * 2. Python output stream: writes output via [e]msg(). 16 * 3. Implementation of the Vim module for Python 17 * 4. Utility functions for handling the interface between Vim and Python. 18 */ 19 20 #include "vim.h" 21 22 #include <limits.h> 23 24 /* uncomment this if used with the debug version of python. 25 * Checked on 2.7.4. */ 26 /* #define Py_DEBUG */ 27 /* Note: most of time you can add -DPy_DEBUG to CFLAGS in place of uncommenting 28 */ 29 /* uncomment this if used with the debug version of python, but without its 30 * allocator */ 31 /* #define Py_DEBUG_NO_PYMALLOC */ 32 33 /* Python.h defines _POSIX_THREADS itself (if needed) */ 34 #ifdef _POSIX_THREADS 35 # undef _POSIX_THREADS 36 #endif 37 38 #if defined(_WIN32) && defined(HAVE_FCNTL_H) 39 # undef HAVE_FCNTL_H 40 #endif 41 42 #ifdef _DEBUG 43 # undef _DEBUG 44 #endif 45 46 #ifdef HAVE_STDARG_H 47 # undef HAVE_STDARG_H /* Python's config.h defines it as well. */ 48 #endif 49 #ifdef _POSIX_C_SOURCE 50 # undef _POSIX_C_SOURCE /* pyconfig.h defines it as well. */ 51 #endif 52 #ifdef _XOPEN_SOURCE 53 # undef _XOPEN_SOURCE /* pyconfig.h defines it as well. */ 54 #endif 55 56 #define PY_SSIZE_T_CLEAN 57 58 #include <Python.h> 59 60 #if !defined(PY_VERSION_HEX) || PY_VERSION_HEX < 0x02050000 61 # undef PY_SSIZE_T_CLEAN 62 #endif 63 64 #if defined(MACOS) && !defined(MACOS_X_UNIX) 65 # include "macglue.h" 66 # include <CodeFragments.h> 67 #endif 68 #undef main /* Defined in python.h - aargh */ 69 #undef HAVE_FCNTL_H /* Clash with os_win32.h */ 70 71 #define PyBytes_FromString PyString_FromString 72 #define PyBytes_Check PyString_Check 73 #define PyBytes_AsStringAndSize PyString_AsStringAndSize 74 75 #if !defined(FEAT_PYTHON) && defined(PROTO) 76 /* Use this to be able to generate prototypes without python being used. */ 77 # define PyObject Py_ssize_t 78 # define PyThreadState Py_ssize_t 79 # define PyTypeObject Py_ssize_t 80 struct PyMethodDef { Py_ssize_t a; }; 81 # define PySequenceMethods Py_ssize_t 82 #endif 83 84 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000 85 # define PY_USE_CAPSULE 86 #endif 87 88 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02050000 89 # define PyInt Py_ssize_t 90 # define PyInquiry lenfunc 91 # define PyIntArgFunc ssizeargfunc 92 # define PyIntIntArgFunc ssizessizeargfunc 93 # define PyIntObjArgProc ssizeobjargproc 94 # define PyIntIntObjArgProc ssizessizeobjargproc 95 # define Py_ssize_t_fmt "n" 96 #else 97 # define PyInt int 98 # define lenfunc inquiry 99 # define PyInquiry inquiry 100 # define PyIntArgFunc intargfunc 101 # define PyIntIntArgFunc intintargfunc 102 # define PyIntObjArgProc intobjargproc 103 # define PyIntIntObjArgProc intintobjargproc 104 # define Py_ssize_t_fmt "i" 105 #endif 106 #define Py_bytes_fmt "s" 107 108 /* Parser flags */ 109 #define single_input 256 110 #define file_input 257 111 #define eval_input 258 112 113 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x020300F0 114 /* Python 2.3: can invoke ":python" recursively. */ 115 # define PY_CAN_RECURSE 116 #endif 117 118 # if defined(DYNAMIC_PYTHON) || defined(PROTO) 119 # ifndef DYNAMIC_PYTHON 120 # define HINSTANCE long_u /* for generating prototypes */ 121 # endif 122 123 # ifndef WIN3264 124 # include <dlfcn.h> 125 # define FARPROC void* 126 # define HINSTANCE void* 127 # if defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL) 128 # define load_dll(n) dlopen((n), RTLD_LAZY) 129 # else 130 # define load_dll(n) dlopen((n), RTLD_LAZY|RTLD_GLOBAL) 131 # endif 132 # define close_dll dlclose 133 # define symbol_from_dll dlsym 134 # else 135 # define load_dll vimLoadLib 136 # define close_dll FreeLibrary 137 # define symbol_from_dll GetProcAddress 138 # endif 139 140 /* This makes if_python.c compile without warnings against Python 2.5 141 * on Win32 and Win64. */ 142 # undef PyRun_SimpleString 143 # undef PyRun_String 144 # undef PyArg_Parse 145 # undef PyArg_ParseTuple 146 # undef Py_BuildValue 147 # undef Py_InitModule4 148 # undef Py_InitModule4_64 149 # undef PyObject_CallMethod 150 # undef PyObject_CallFunction 151 152 /* 153 * Wrapper defines 154 */ 155 # define PyArg_Parse dll_PyArg_Parse 156 # define PyArg_ParseTuple dll_PyArg_ParseTuple 157 # define PyMem_Free dll_PyMem_Free 158 # define PyMem_Malloc dll_PyMem_Malloc 159 # define PyDict_SetItemString dll_PyDict_SetItemString 160 # define PyErr_BadArgument dll_PyErr_BadArgument 161 # define PyErr_NewException dll_PyErr_NewException 162 # define PyErr_Clear dll_PyErr_Clear 163 # define PyErr_Format dll_PyErr_Format 164 # define PyErr_PrintEx dll_PyErr_PrintEx 165 # define PyErr_NoMemory dll_PyErr_NoMemory 166 # define PyErr_Occurred dll_PyErr_Occurred 167 # define PyErr_SetNone dll_PyErr_SetNone 168 # define PyErr_SetString dll_PyErr_SetString 169 # define PyErr_SetObject dll_PyErr_SetObject 170 # define PyErr_ExceptionMatches dll_PyErr_ExceptionMatches 171 # define PyEval_InitThreads dll_PyEval_InitThreads 172 # define PyEval_RestoreThread dll_PyEval_RestoreThread 173 # define PyEval_SaveThread dll_PyEval_SaveThread 174 # ifdef PY_CAN_RECURSE 175 # define PyGILState_Ensure dll_PyGILState_Ensure 176 # define PyGILState_Release dll_PyGILState_Release 177 # endif 178 # define PyInt_AsLong dll_PyInt_AsLong 179 # define PyInt_FromLong dll_PyInt_FromLong 180 # define PyLong_AsLong dll_PyLong_AsLong 181 # define PyLong_FromLong dll_PyLong_FromLong 182 # define PyBool_Type (*dll_PyBool_Type) 183 # define PyInt_Type (*dll_PyInt_Type) 184 # define PyLong_Type (*dll_PyLong_Type) 185 # define PyList_GetItem dll_PyList_GetItem 186 # define PyList_Append dll_PyList_Append 187 # define PyList_Insert dll_PyList_Insert 188 # define PyList_New dll_PyList_New 189 # define PyList_SetItem dll_PyList_SetItem 190 # define PyList_Size dll_PyList_Size 191 # define PyList_Type (*dll_PyList_Type) 192 # define PySequence_Check dll_PySequence_Check 193 # define PySequence_Size dll_PySequence_Size 194 # define PySequence_GetItem dll_PySequence_GetItem 195 # define PySequence_Fast dll_PySequence_Fast 196 # define PyTuple_Size dll_PyTuple_Size 197 # define PyTuple_GetItem dll_PyTuple_GetItem 198 # define PyTuple_Type (*dll_PyTuple_Type) 199 # define PyImport_ImportModule dll_PyImport_ImportModule 200 # define PyDict_New dll_PyDict_New 201 # define PyDict_GetItemString dll_PyDict_GetItemString 202 # define PyDict_Next dll_PyDict_Next 203 # define PyDict_Type (*dll_PyDict_Type) 204 # ifdef PyMapping_Keys 205 # define PY_NO_MAPPING_KEYS 206 # else 207 # define PyMapping_Keys dll_PyMapping_Keys 208 # endif 209 # define PyObject_GetItem dll_PyObject_GetItem 210 # define PyObject_CallMethod dll_PyObject_CallMethod 211 # define PyMapping_Check dll_PyMapping_Check 212 # define PyIter_Next dll_PyIter_Next 213 # define PyModule_GetDict dll_PyModule_GetDict 214 # define PyModule_AddObject dll_PyModule_AddObject 215 # define PyRun_SimpleString dll_PyRun_SimpleString 216 # define PyRun_String dll_PyRun_String 217 # define PyObject_GetAttrString dll_PyObject_GetAttrString 218 # define PyObject_HasAttrString dll_PyObject_HasAttrString 219 # define PyObject_SetAttrString dll_PyObject_SetAttrString 220 # define PyObject_CallFunctionObjArgs dll_PyObject_CallFunctionObjArgs 221 # define PyObject_CallFunction dll_PyObject_CallFunction 222 # define PyObject_Call dll_PyObject_Call 223 # define PyObject_Repr dll_PyObject_Repr 224 # define PyString_AsString dll_PyString_AsString 225 # define PyString_AsStringAndSize dll_PyString_AsStringAndSize 226 # define PyString_FromString dll_PyString_FromString 227 # define PyString_FromFormat dll_PyString_FromFormat 228 # define PyString_FromStringAndSize dll_PyString_FromStringAndSize 229 # define PyString_Size dll_PyString_Size 230 # define PyString_Type (*dll_PyString_Type) 231 # define PyUnicode_Type (*dll_PyUnicode_Type) 232 # undef PyUnicode_AsEncodedString 233 # define PyUnicode_AsEncodedString py_PyUnicode_AsEncodedString 234 # define PyFloat_AsDouble dll_PyFloat_AsDouble 235 # define PyFloat_FromDouble dll_PyFloat_FromDouble 236 # define PyFloat_Type (*dll_PyFloat_Type) 237 # define PyNumber_Check dll_PyNumber_Check 238 # define PyNumber_Long dll_PyNumber_Long 239 # define PyImport_AddModule (*dll_PyImport_AddModule) 240 # define PySys_SetObject dll_PySys_SetObject 241 # define PySys_GetObject dll_PySys_GetObject 242 # define PySys_SetArgv dll_PySys_SetArgv 243 # define PyType_Type (*dll_PyType_Type) 244 # define PyType_Ready (*dll_PyType_Ready) 245 # define PyType_GenericAlloc dll_PyType_GenericAlloc 246 # define Py_BuildValue dll_Py_BuildValue 247 # define Py_FindMethod dll_Py_FindMethod 248 # define Py_InitModule4 dll_Py_InitModule4 249 # define Py_SetPythonHome dll_Py_SetPythonHome 250 # define Py_Initialize dll_Py_Initialize 251 # define Py_Finalize dll_Py_Finalize 252 # define Py_IsInitialized dll_Py_IsInitialized 253 # define _PyObject_New dll__PyObject_New 254 # define _PyObject_GC_New dll__PyObject_GC_New 255 # ifdef PyObject_GC_Del 256 # define Py_underscore_GC 257 # define _PyObject_GC_Del dll__PyObject_GC_Del 258 # define _PyObject_GC_UnTrack dll__PyObject_GC_UnTrack 259 # else 260 # define PyObject_GC_Del dll_PyObject_GC_Del 261 # define PyObject_GC_UnTrack dll_PyObject_GC_UnTrack 262 # endif 263 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000 264 # define _PyObject_NextNotImplemented (*dll__PyObject_NextNotImplemented) 265 # endif 266 # define _Py_NoneStruct (*dll__Py_NoneStruct) 267 # define _Py_ZeroStruct (*dll__Py_ZeroStruct) 268 # define _Py_TrueStruct (*dll__Py_TrueStruct) 269 # define PyObject_Init dll__PyObject_Init 270 # define PyObject_GetIter dll_PyObject_GetIter 271 # define PyObject_IsTrue dll_PyObject_IsTrue 272 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000 273 # define PyType_IsSubtype dll_PyType_IsSubtype 274 # ifdef Py_DEBUG 275 # define _Py_NegativeRefcount dll__Py_NegativeRefcount 276 # define _Py_RefTotal (*dll__Py_RefTotal) 277 # define _Py_Dealloc dll__Py_Dealloc 278 # endif 279 # endif 280 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000 281 # if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC) 282 # define _PyObject_DebugMalloc dll__PyObject_DebugMalloc 283 # define _PyObject_DebugFree dll__PyObject_DebugFree 284 # else 285 # define PyObject_Malloc dll_PyObject_Malloc 286 # define PyObject_Free dll_PyObject_Free 287 # endif 288 # endif 289 # ifdef PY_USE_CAPSULE 290 # define PyCapsule_New dll_PyCapsule_New 291 # define PyCapsule_GetPointer dll_PyCapsule_GetPointer 292 # else 293 # define PyCObject_FromVoidPtr dll_PyCObject_FromVoidPtr 294 # define PyCObject_AsVoidPtr dll_PyCObject_AsVoidPtr 295 # endif 296 297 /* 298 * Pointers for dynamic link 299 */ 300 static int(*dll_PyArg_Parse)(PyObject *, char *, ...); 301 static int(*dll_PyArg_ParseTuple)(PyObject *, char *, ...); 302 static int(*dll_PyMem_Free)(void *); 303 static void* (*dll_PyMem_Malloc)(size_t); 304 static int(*dll_PyDict_SetItemString)(PyObject *dp, char *key, PyObject *item); 305 static int(*dll_PyErr_BadArgument)(void); 306 static PyObject *(*dll_PyErr_NewException)(char *, PyObject *, PyObject *); 307 static void(*dll_PyErr_Clear)(void); 308 static PyObject*(*dll_PyErr_Format)(PyObject *, const char *, ...); 309 static void(*dll_PyErr_PrintEx)(int); 310 static PyObject*(*dll_PyErr_NoMemory)(void); 311 static PyObject*(*dll_PyErr_Occurred)(void); 312 static void(*dll_PyErr_SetNone)(PyObject *); 313 static void(*dll_PyErr_SetString)(PyObject *, const char *); 314 static void(*dll_PyErr_SetObject)(PyObject *, PyObject *); 315 static int(*dll_PyErr_ExceptionMatches)(PyObject *); 316 static void(*dll_PyEval_InitThreads)(void); 317 static void(*dll_PyEval_RestoreThread)(PyThreadState *); 318 static PyThreadState*(*dll_PyEval_SaveThread)(void); 319 # ifdef PY_CAN_RECURSE 320 static PyGILState_STATE (*dll_PyGILState_Ensure)(void); 321 static void (*dll_PyGILState_Release)(PyGILState_STATE); 322 # endif 323 static long(*dll_PyInt_AsLong)(PyObject *); 324 static PyObject*(*dll_PyInt_FromLong)(long); 325 static long(*dll_PyLong_AsLong)(PyObject *); 326 static PyObject*(*dll_PyLong_FromLong)(long); 327 static PyTypeObject* dll_PyBool_Type; 328 static PyTypeObject* dll_PyInt_Type; 329 static PyTypeObject* dll_PyLong_Type; 330 static PyObject*(*dll_PyList_GetItem)(PyObject *, PyInt); 331 static int(*dll_PyList_Append)(PyObject *, PyObject *); 332 static int(*dll_PyList_Insert)(PyObject *, PyInt, PyObject *); 333 static PyObject*(*dll_PyList_New)(PyInt size); 334 static int(*dll_PyList_SetItem)(PyObject *, PyInt, PyObject *); 335 static PyInt(*dll_PyList_Size)(PyObject *); 336 static PyTypeObject* dll_PyList_Type; 337 static int (*dll_PySequence_Check)(PyObject *); 338 static PyInt(*dll_PySequence_Size)(PyObject *); 339 static PyObject*(*dll_PySequence_GetItem)(PyObject *, PyInt); 340 static PyObject*(*dll_PySequence_Fast)(PyObject *, const char *); 341 static PyInt(*dll_PyTuple_Size)(PyObject *); 342 static PyObject*(*dll_PyTuple_GetItem)(PyObject *, PyInt); 343 static PyTypeObject* dll_PyTuple_Type; 344 static PyObject*(*dll_PyImport_ImportModule)(const char *); 345 static PyObject*(*dll_PyDict_New)(void); 346 static PyObject*(*dll_PyDict_GetItemString)(PyObject *, const char *); 347 static int (*dll_PyDict_Next)(PyObject *, PyInt *, PyObject **, PyObject **); 348 static PyTypeObject* dll_PyDict_Type; 349 # ifndef PY_NO_MAPPING_KEYS 350 static PyObject* (*dll_PyMapping_Keys)(PyObject *); 351 # endif 352 static PyObject* (*dll_PyObject_GetItem)(PyObject *, PyObject *); 353 static PyObject* (*dll_PyObject_CallMethod)(PyObject *, char *, PyObject *); 354 static int (*dll_PyMapping_Check)(PyObject *); 355 static PyObject* (*dll_PyIter_Next)(PyObject *); 356 static PyObject*(*dll_PyModule_GetDict)(PyObject *); 357 static int(*dll_PyModule_AddObject)(PyObject *, const char *, PyObject *); 358 static int(*dll_PyRun_SimpleString)(char *); 359 static PyObject *(*dll_PyRun_String)(char *, int, PyObject *, PyObject *); 360 static PyObject* (*dll_PyObject_GetAttrString)(PyObject *, const char *); 361 static int (*dll_PyObject_HasAttrString)(PyObject *, const char *); 362 static int (*dll_PyObject_SetAttrString)(PyObject *, const char *, PyObject *); 363 static PyObject* (*dll_PyObject_CallFunctionObjArgs)(PyObject *, ...); 364 static PyObject* (*dll_PyObject_CallFunction)(PyObject *, char *, ...); 365 static PyObject* (*dll_PyObject_Call)(PyObject *, PyObject *, PyObject *); 366 static PyObject* (*dll_PyObject_Repr)(PyObject *); 367 static char*(*dll_PyString_AsString)(PyObject *); 368 static int(*dll_PyString_AsStringAndSize)(PyObject *, char **, PyInt *); 369 static PyObject*(*dll_PyString_FromString)(const char *); 370 static PyObject*(*dll_PyString_FromFormat)(const char *, ...); 371 static PyObject*(*dll_PyString_FromStringAndSize)(const char *, PyInt); 372 static PyInt(*dll_PyString_Size)(PyObject *); 373 static PyTypeObject* dll_PyString_Type; 374 static PyTypeObject* dll_PyUnicode_Type; 375 static PyObject *(*py_PyUnicode_AsEncodedString)(PyObject *, char *, char *); 376 static double(*dll_PyFloat_AsDouble)(PyObject *); 377 static PyObject*(*dll_PyFloat_FromDouble)(double); 378 static PyTypeObject* dll_PyFloat_Type; 379 static int(*dll_PyNumber_Check)(PyObject *); 380 static PyObject*(*dll_PyNumber_Long)(PyObject *); 381 static int(*dll_PySys_SetObject)(char *, PyObject *); 382 static PyObject *(*dll_PySys_GetObject)(char *); 383 static int(*dll_PySys_SetArgv)(int, char **); 384 static PyTypeObject* dll_PyType_Type; 385 static int (*dll_PyType_Ready)(PyTypeObject *type); 386 static PyObject* (*dll_PyType_GenericAlloc)(PyTypeObject *type, PyInt nitems); 387 static PyObject*(*dll_Py_BuildValue)(char *, ...); 388 static PyObject*(*dll_Py_FindMethod)(struct PyMethodDef[], PyObject *, char *); 389 static PyObject*(*dll_Py_InitModule4)(char *, struct PyMethodDef *, char *, PyObject *, int); 390 static PyObject*(*dll_PyImport_AddModule)(char *); 391 static void(*dll_Py_SetPythonHome)(char *home); 392 static void(*dll_Py_Initialize)(void); 393 static void(*dll_Py_Finalize)(void); 394 static int(*dll_Py_IsInitialized)(void); 395 static PyObject*(*dll__PyObject_New)(PyTypeObject *, PyObject *); 396 static PyObject*(*dll__PyObject_GC_New)(PyTypeObject *); 397 # ifdef Py_underscore_GC 398 static void(*dll__PyObject_GC_Del)(void *); 399 static void(*dll__PyObject_GC_UnTrack)(void *); 400 # else 401 static void(*dll_PyObject_GC_Del)(void *); 402 static void(*dll_PyObject_GC_UnTrack)(void *); 403 # endif 404 static PyObject*(*dll__PyObject_Init)(PyObject *, PyTypeObject *); 405 static PyObject* (*dll_PyObject_GetIter)(PyObject *); 406 static int (*dll_PyObject_IsTrue)(PyObject *); 407 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000 408 static iternextfunc dll__PyObject_NextNotImplemented; 409 # endif 410 static PyObject* dll__Py_NoneStruct; 411 static PyObject* _Py_ZeroStruct; 412 static PyObject* dll__Py_TrueStruct; 413 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000 414 static int (*dll_PyType_IsSubtype)(PyTypeObject *, PyTypeObject *); 415 # ifdef Py_DEBUG 416 static void (*dll__Py_NegativeRefcount)(const char *fname, int lineno, PyObject *op); 417 static PyInt* dll__Py_RefTotal; 418 static void (*dll__Py_Dealloc)(PyObject *obj); 419 # endif 420 # endif 421 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000 422 # if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC) 423 static void (*dll__PyObject_DebugFree)(void*); 424 static void* (*dll__PyObject_DebugMalloc)(size_t); 425 # else 426 static void* (*dll_PyObject_Malloc)(size_t); 427 static void (*dll_PyObject_Free)(void*); 428 # endif 429 # endif 430 # ifdef PY_USE_CAPSULE 431 static PyObject* (*dll_PyCapsule_New)(void *, char *, PyCapsule_Destructor); 432 static void* (*dll_PyCapsule_GetPointer)(PyObject *, char *); 433 # else 434 static PyObject* (*dll_PyCObject_FromVoidPtr)(void *cobj, void (*destr)(void *)); 435 static void* (*dll_PyCObject_AsVoidPtr)(PyObject *); 436 # endif 437 438 static HINSTANCE hinstPython = 0; /* Instance of python.dll */ 439 440 /* Imported exception objects */ 441 static PyObject *imp_PyExc_AttributeError; 442 static PyObject *imp_PyExc_IndexError; 443 static PyObject *imp_PyExc_KeyError; 444 static PyObject *imp_PyExc_KeyboardInterrupt; 445 static PyObject *imp_PyExc_TypeError; 446 static PyObject *imp_PyExc_ValueError; 447 static PyObject *imp_PyExc_SystemExit; 448 static PyObject *imp_PyExc_RuntimeError; 449 static PyObject *imp_PyExc_ImportError; 450 static PyObject *imp_PyExc_OverflowError; 451 452 # define PyExc_AttributeError imp_PyExc_AttributeError 453 # define PyExc_IndexError imp_PyExc_IndexError 454 # define PyExc_KeyError imp_PyExc_KeyError 455 # define PyExc_KeyboardInterrupt imp_PyExc_KeyboardInterrupt 456 # define PyExc_TypeError imp_PyExc_TypeError 457 # define PyExc_ValueError imp_PyExc_ValueError 458 # define PyExc_SystemExit imp_PyExc_SystemExit 459 # define PyExc_RuntimeError imp_PyExc_RuntimeError 460 # define PyExc_ImportError imp_PyExc_ImportError 461 # define PyExc_OverflowError imp_PyExc_OverflowError 462 463 /* 464 * Table of name to function pointer of python. 465 */ 466 # define PYTHON_PROC FARPROC 467 static struct 468 { 469 char *name; 470 PYTHON_PROC *ptr; 471 } python_funcname_table[] = 472 { 473 #ifndef PY_SSIZE_T_CLEAN 474 {"PyArg_Parse", (PYTHON_PROC*)&dll_PyArg_Parse}, 475 {"PyArg_ParseTuple", (PYTHON_PROC*)&dll_PyArg_ParseTuple}, 476 {"Py_BuildValue", (PYTHON_PROC*)&dll_Py_BuildValue}, 477 #else 478 {"_PyArg_Parse_SizeT", (PYTHON_PROC*)&dll_PyArg_Parse}, 479 {"_PyArg_ParseTuple_SizeT", (PYTHON_PROC*)&dll_PyArg_ParseTuple}, 480 {"_Py_BuildValue_SizeT", (PYTHON_PROC*)&dll_Py_BuildValue}, 481 #endif 482 {"PyMem_Free", (PYTHON_PROC*)&dll_PyMem_Free}, 483 {"PyMem_Malloc", (PYTHON_PROC*)&dll_PyMem_Malloc}, 484 {"PyDict_SetItemString", (PYTHON_PROC*)&dll_PyDict_SetItemString}, 485 {"PyErr_BadArgument", (PYTHON_PROC*)&dll_PyErr_BadArgument}, 486 {"PyErr_NewException", (PYTHON_PROC*)&dll_PyErr_NewException}, 487 {"PyErr_Clear", (PYTHON_PROC*)&dll_PyErr_Clear}, 488 {"PyErr_Format", (PYTHON_PROC*)&dll_PyErr_Format}, 489 {"PyErr_PrintEx", (PYTHON_PROC*)&dll_PyErr_PrintEx}, 490 {"PyErr_NoMemory", (PYTHON_PROC*)&dll_PyErr_NoMemory}, 491 {"PyErr_Occurred", (PYTHON_PROC*)&dll_PyErr_Occurred}, 492 {"PyErr_SetNone", (PYTHON_PROC*)&dll_PyErr_SetNone}, 493 {"PyErr_SetString", (PYTHON_PROC*)&dll_PyErr_SetString}, 494 {"PyErr_SetObject", (PYTHON_PROC*)&dll_PyErr_SetObject}, 495 {"PyErr_ExceptionMatches", (PYTHON_PROC*)&dll_PyErr_ExceptionMatches}, 496 {"PyEval_InitThreads", (PYTHON_PROC*)&dll_PyEval_InitThreads}, 497 {"PyEval_RestoreThread", (PYTHON_PROC*)&dll_PyEval_RestoreThread}, 498 {"PyEval_SaveThread", (PYTHON_PROC*)&dll_PyEval_SaveThread}, 499 # ifdef PY_CAN_RECURSE 500 {"PyGILState_Ensure", (PYTHON_PROC*)&dll_PyGILState_Ensure}, 501 {"PyGILState_Release", (PYTHON_PROC*)&dll_PyGILState_Release}, 502 # endif 503 {"PyInt_AsLong", (PYTHON_PROC*)&dll_PyInt_AsLong}, 504 {"PyInt_FromLong", (PYTHON_PROC*)&dll_PyInt_FromLong}, 505 {"PyLong_AsLong", (PYTHON_PROC*)&dll_PyLong_AsLong}, 506 {"PyLong_FromLong", (PYTHON_PROC*)&dll_PyLong_FromLong}, 507 {"PyBool_Type", (PYTHON_PROC*)&dll_PyBool_Type}, 508 {"PyInt_Type", (PYTHON_PROC*)&dll_PyInt_Type}, 509 {"PyLong_Type", (PYTHON_PROC*)&dll_PyLong_Type}, 510 {"PyList_GetItem", (PYTHON_PROC*)&dll_PyList_GetItem}, 511 {"PyList_Append", (PYTHON_PROC*)&dll_PyList_Append}, 512 {"PyList_Insert", (PYTHON_PROC*)&dll_PyList_Insert}, 513 {"PyList_New", (PYTHON_PROC*)&dll_PyList_New}, 514 {"PyList_SetItem", (PYTHON_PROC*)&dll_PyList_SetItem}, 515 {"PyList_Size", (PYTHON_PROC*)&dll_PyList_Size}, 516 {"PyList_Type", (PYTHON_PROC*)&dll_PyList_Type}, 517 {"PySequence_Size", (PYTHON_PROC*)&dll_PySequence_Size}, 518 {"PySequence_Check", (PYTHON_PROC*)&dll_PySequence_Check}, 519 {"PySequence_GetItem", (PYTHON_PROC*)&dll_PySequence_GetItem}, 520 {"PySequence_Fast", (PYTHON_PROC*)&dll_PySequence_Fast}, 521 {"PyTuple_GetItem", (PYTHON_PROC*)&dll_PyTuple_GetItem}, 522 {"PyTuple_Size", (PYTHON_PROC*)&dll_PyTuple_Size}, 523 {"PyTuple_Type", (PYTHON_PROC*)&dll_PyTuple_Type}, 524 {"PyImport_ImportModule", (PYTHON_PROC*)&dll_PyImport_ImportModule}, 525 {"PyDict_GetItemString", (PYTHON_PROC*)&dll_PyDict_GetItemString}, 526 {"PyDict_Next", (PYTHON_PROC*)&dll_PyDict_Next}, 527 {"PyDict_New", (PYTHON_PROC*)&dll_PyDict_New}, 528 {"PyDict_Type", (PYTHON_PROC*)&dll_PyDict_Type}, 529 # ifndef PY_NO_MAPPING_KEYS 530 {"PyMapping_Keys", (PYTHON_PROC*)&dll_PyMapping_Keys}, 531 # endif 532 {"PyObject_GetItem", (PYTHON_PROC*)&dll_PyObject_GetItem}, 533 {"PyObject_CallMethod", (PYTHON_PROC*)&dll_PyObject_CallMethod}, 534 {"PyMapping_Check", (PYTHON_PROC*)&dll_PyMapping_Check}, 535 {"PyIter_Next", (PYTHON_PROC*)&dll_PyIter_Next}, 536 {"PyModule_GetDict", (PYTHON_PROC*)&dll_PyModule_GetDict}, 537 {"PyModule_AddObject", (PYTHON_PROC*)&dll_PyModule_AddObject}, 538 {"PyRun_SimpleString", (PYTHON_PROC*)&dll_PyRun_SimpleString}, 539 {"PyRun_String", (PYTHON_PROC*)&dll_PyRun_String}, 540 {"PyObject_GetAttrString", (PYTHON_PROC*)&dll_PyObject_GetAttrString}, 541 {"PyObject_HasAttrString", (PYTHON_PROC*)&dll_PyObject_HasAttrString}, 542 {"PyObject_SetAttrString", (PYTHON_PROC*)&dll_PyObject_SetAttrString}, 543 {"PyObject_CallFunctionObjArgs", (PYTHON_PROC*)&dll_PyObject_CallFunctionObjArgs}, 544 {"PyObject_CallFunction", (PYTHON_PROC*)&dll_PyObject_CallFunction}, 545 {"PyObject_Call", (PYTHON_PROC*)&dll_PyObject_Call}, 546 {"PyObject_Repr", (PYTHON_PROC*)&dll_PyObject_Repr}, 547 {"PyString_AsString", (PYTHON_PROC*)&dll_PyString_AsString}, 548 {"PyString_AsStringAndSize", (PYTHON_PROC*)&dll_PyString_AsStringAndSize}, 549 {"PyString_FromString", (PYTHON_PROC*)&dll_PyString_FromString}, 550 {"PyString_FromFormat", (PYTHON_PROC*)&dll_PyString_FromFormat}, 551 {"PyString_FromStringAndSize", (PYTHON_PROC*)&dll_PyString_FromStringAndSize}, 552 {"PyString_Size", (PYTHON_PROC*)&dll_PyString_Size}, 553 {"PyString_Type", (PYTHON_PROC*)&dll_PyString_Type}, 554 {"PyUnicode_Type", (PYTHON_PROC*)&dll_PyUnicode_Type}, 555 {"PyFloat_Type", (PYTHON_PROC*)&dll_PyFloat_Type}, 556 {"PyFloat_AsDouble", (PYTHON_PROC*)&dll_PyFloat_AsDouble}, 557 {"PyFloat_FromDouble", (PYTHON_PROC*)&dll_PyFloat_FromDouble}, 558 {"PyImport_AddModule", (PYTHON_PROC*)&dll_PyImport_AddModule}, 559 {"PyNumber_Check", (PYTHON_PROC*)&dll_PyNumber_Check}, 560 {"PyNumber_Long", (PYTHON_PROC*)&dll_PyNumber_Long}, 561 {"PySys_SetObject", (PYTHON_PROC*)&dll_PySys_SetObject}, 562 {"PySys_GetObject", (PYTHON_PROC*)&dll_PySys_GetObject}, 563 {"PySys_SetArgv", (PYTHON_PROC*)&dll_PySys_SetArgv}, 564 {"PyType_Type", (PYTHON_PROC*)&dll_PyType_Type}, 565 {"PyType_Ready", (PYTHON_PROC*)&dll_PyType_Ready}, 566 {"PyType_GenericAlloc", (PYTHON_PROC*)&dll_PyType_GenericAlloc}, 567 {"Py_FindMethod", (PYTHON_PROC*)&dll_Py_FindMethod}, 568 {"Py_SetPythonHome", (PYTHON_PROC*)&dll_Py_SetPythonHome}, 569 {"Py_Initialize", (PYTHON_PROC*)&dll_Py_Initialize}, 570 {"Py_Finalize", (PYTHON_PROC*)&dll_Py_Finalize}, 571 {"Py_IsInitialized", (PYTHON_PROC*)&dll_Py_IsInitialized}, 572 {"_PyObject_New", (PYTHON_PROC*)&dll__PyObject_New}, 573 {"_PyObject_GC_New", (PYTHON_PROC*)&dll__PyObject_GC_New}, 574 # ifdef Py_underscore_GC 575 {"_PyObject_GC_Del", (PYTHON_PROC*)&dll__PyObject_GC_Del}, 576 {"_PyObject_GC_UnTrack", (PYTHON_PROC*)&dll__PyObject_GC_UnTrack}, 577 # else 578 {"PyObject_GC_Del", (PYTHON_PROC*)&dll_PyObject_GC_Del}, 579 {"PyObject_GC_UnTrack", (PYTHON_PROC*)&dll_PyObject_GC_UnTrack}, 580 # endif 581 {"PyObject_Init", (PYTHON_PROC*)&dll__PyObject_Init}, 582 {"PyObject_GetIter", (PYTHON_PROC*)&dll_PyObject_GetIter}, 583 {"PyObject_IsTrue", (PYTHON_PROC*)&dll_PyObject_IsTrue}, 584 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000 585 {"_PyObject_NextNotImplemented", (PYTHON_PROC*)&dll__PyObject_NextNotImplemented}, 586 # endif 587 {"_Py_NoneStruct", (PYTHON_PROC*)&dll__Py_NoneStruct}, 588 {"_Py_ZeroStruct", (PYTHON_PROC*)&dll__Py_ZeroStruct}, 589 {"_Py_TrueStruct", (PYTHON_PROC*)&dll__Py_TrueStruct}, 590 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000 591 # ifdef Py_DEBUG 592 {"_Py_NegativeRefcount", (PYTHON_PROC*)&dll__Py_NegativeRefcount}, 593 {"_Py_RefTotal", (PYTHON_PROC*)&dll__Py_RefTotal}, 594 {"_Py_Dealloc", (PYTHON_PROC*)&dll__Py_Dealloc}, 595 # endif 596 {"PyType_IsSubtype", (PYTHON_PROC*)&dll_PyType_IsSubtype}, 597 # endif 598 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000 599 # if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC) 600 {"_PyObject_DebugFree", (PYTHON_PROC*)&dll__PyObject_DebugFree}, 601 {"_PyObject_DebugMalloc", (PYTHON_PROC*)&dll__PyObject_DebugMalloc}, 602 # else 603 {"PyObject_Malloc", (PYTHON_PROC*)&dll_PyObject_Malloc}, 604 {"PyObject_Free", (PYTHON_PROC*)&dll_PyObject_Free}, 605 # endif 606 # endif 607 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02050000 \ 608 && SIZEOF_SIZE_T != SIZEOF_INT 609 # ifdef Py_DEBUG 610 {"Py_InitModule4TraceRefs_64", (PYTHON_PROC*)&dll_Py_InitModule4}, 611 # else 612 {"Py_InitModule4_64", (PYTHON_PROC*)&dll_Py_InitModule4}, 613 # endif 614 # else 615 # ifdef Py_DEBUG 616 {"Py_InitModule4TraceRefs", (PYTHON_PROC*)&dll_Py_InitModule4}, 617 # else 618 {"Py_InitModule4", (PYTHON_PROC*)&dll_Py_InitModule4}, 619 # endif 620 # endif 621 # ifdef PY_USE_CAPSULE 622 {"PyCapsule_New", (PYTHON_PROC*)&dll_PyCapsule_New}, 623 {"PyCapsule_GetPointer", (PYTHON_PROC*)&dll_PyCapsule_GetPointer}, 624 # else 625 {"PyCObject_FromVoidPtr", (PYTHON_PROC*)&dll_PyCObject_FromVoidPtr}, 626 {"PyCObject_AsVoidPtr", (PYTHON_PROC*)&dll_PyCObject_AsVoidPtr}, 627 # endif 628 {"", NULL}, 629 }; 630 631 /* 632 * Free python.dll 633 */ 634 static void 635 end_dynamic_python(void) 636 { 637 if (hinstPython) 638 { 639 close_dll(hinstPython); 640 hinstPython = 0; 641 } 642 } 643 644 /* 645 * Load library and get all pointers. 646 * Parameter 'libname' provides name of DLL. 647 * Return OK or FAIL. 648 */ 649 static int 650 python_runtime_link_init(char *libname, int verbose) 651 { 652 int i; 653 void *ucs_as_encoded_string; 654 655 #if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON3) 656 /* Can't have Python and Python3 loaded at the same time. 657 * It cause a crash, because RTLD_GLOBAL is needed for 658 * standard C extension libraries of one or both python versions. */ 659 if (python3_loaded()) 660 { 661 if (verbose) 662 EMSG(_("E836: This Vim cannot execute :python after using :py3")); 663 return FAIL; 664 } 665 #endif 666 667 if (hinstPython) 668 return OK; 669 hinstPython = load_dll(libname); 670 if (!hinstPython) 671 { 672 if (verbose) 673 EMSG2(_(e_loadlib), libname); 674 return FAIL; 675 } 676 677 for (i = 0; python_funcname_table[i].ptr; ++i) 678 { 679 if ((*python_funcname_table[i].ptr = symbol_from_dll(hinstPython, 680 python_funcname_table[i].name)) == NULL) 681 { 682 close_dll(hinstPython); 683 hinstPython = 0; 684 if (verbose) 685 EMSG2(_(e_loadfunc), python_funcname_table[i].name); 686 return FAIL; 687 } 688 } 689 690 /* Load unicode functions separately as only the ucs2 or the ucs4 functions 691 * will be present in the library. */ 692 ucs_as_encoded_string = symbol_from_dll(hinstPython, 693 "PyUnicodeUCS2_AsEncodedString"); 694 if (ucs_as_encoded_string == NULL) 695 ucs_as_encoded_string = symbol_from_dll(hinstPython, 696 "PyUnicodeUCS4_AsEncodedString"); 697 if (ucs_as_encoded_string != NULL) 698 py_PyUnicode_AsEncodedString = ucs_as_encoded_string; 699 else 700 { 701 close_dll(hinstPython); 702 hinstPython = 0; 703 if (verbose) 704 EMSG2(_(e_loadfunc), "PyUnicode_UCSX_*"); 705 return FAIL; 706 } 707 708 return OK; 709 } 710 711 /* 712 * If python is enabled (there is installed python on Windows system) return 713 * TRUE, else FALSE. 714 */ 715 int 716 python_enabled(int verbose) 717 { 718 return python_runtime_link_init(DYNAMIC_PYTHON_DLL, verbose) == OK; 719 } 720 721 /* 722 * Load the standard Python exceptions - don't import the symbols from the 723 * DLL, as this can cause errors (importing data symbols is not reliable). 724 */ 725 static void 726 get_exceptions(void) 727 { 728 PyObject *exmod = PyImport_ImportModule("exceptions"); 729 PyObject *exdict = PyModule_GetDict(exmod); 730 imp_PyExc_AttributeError = PyDict_GetItemString(exdict, "AttributeError"); 731 imp_PyExc_IndexError = PyDict_GetItemString(exdict, "IndexError"); 732 imp_PyExc_KeyError = PyDict_GetItemString(exdict, "KeyError"); 733 imp_PyExc_KeyboardInterrupt = PyDict_GetItemString(exdict, "KeyboardInterrupt"); 734 imp_PyExc_TypeError = PyDict_GetItemString(exdict, "TypeError"); 735 imp_PyExc_ValueError = PyDict_GetItemString(exdict, "ValueError"); 736 imp_PyExc_SystemExit = PyDict_GetItemString(exdict, "SystemExit"); 737 imp_PyExc_RuntimeError = PyDict_GetItemString(exdict, "RuntimeError"); 738 imp_PyExc_ImportError = PyDict_GetItemString(exdict, "ImportError"); 739 imp_PyExc_OverflowError = PyDict_GetItemString(exdict, "OverflowError"); 740 Py_XINCREF(imp_PyExc_AttributeError); 741 Py_XINCREF(imp_PyExc_IndexError); 742 Py_XINCREF(imp_PyExc_KeyError); 743 Py_XINCREF(imp_PyExc_KeyboardInterrupt); 744 Py_XINCREF(imp_PyExc_TypeError); 745 Py_XINCREF(imp_PyExc_ValueError); 746 Py_XINCREF(imp_PyExc_SystemExit); 747 Py_XINCREF(imp_PyExc_RuntimeError); 748 Py_XINCREF(imp_PyExc_ImportError); 749 Py_XINCREF(imp_PyExc_OverflowError); 750 Py_XDECREF(exmod); 751 } 752 #endif /* DYNAMIC_PYTHON */ 753 754 static int initialised = 0; 755 #define PYINITIALISED initialised 756 757 #define DESTRUCTOR_FINISH(self) self->ob_type->tp_free((PyObject*)self); 758 759 #define WIN_PYTHON_REF(win) win->w_python_ref 760 #define BUF_PYTHON_REF(buf) buf->b_python_ref 761 #define TAB_PYTHON_REF(tab) tab->tp_python_ref 762 763 static PyObject *OutputGetattr(PyObject *, char *); 764 static PyObject *BufferGetattr(PyObject *, char *); 765 static PyObject *WindowGetattr(PyObject *, char *); 766 static PyObject *TabPageGetattr(PyObject *, char *); 767 static PyObject *RangeGetattr(PyObject *, char *); 768 static PyObject *DictionaryGetattr(PyObject *, char*); 769 static PyObject *ListGetattr(PyObject *, char *); 770 static PyObject *FunctionGetattr(PyObject *, char *); 771 772 #ifndef Py_VISIT 773 # define Py_VISIT(obj) visit(obj, arg) 774 #endif 775 #ifndef Py_CLEAR 776 # define Py_CLEAR(obj) \ 777 { \ 778 Py_XDECREF(obj); \ 779 obj = NULL; \ 780 } 781 #endif 782 783 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE) 784 static void * 785 py_memsave(void *p, size_t len) 786 { 787 void *r; 788 789 if (!(r = PyMem_Malloc(len))) 790 return NULL; 791 mch_memmove(r, p, len); 792 return r; 793 } 794 795 # define PY_STRSAVE(s) ((char_u *) py_memsave(s, STRLEN(s) + 1)) 796 #endif 797 798 /* 799 * Include the code shared with if_python3.c 800 */ 801 #include "if_py_both.h" 802 803 804 /****************************************************** 805 * Internal function prototypes. 806 */ 807 808 static int PythonMod_Init(void); 809 810 811 /****************************************************** 812 * 1. Python interpreter main program. 813 */ 814 815 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */ 816 typedef PyObject PyThreadState; 817 #endif 818 819 #ifndef PY_CAN_RECURSE 820 static PyThreadState *saved_python_thread = NULL; 821 822 /* 823 * Suspend a thread of the Python interpreter, other threads are allowed to 824 * run. 825 */ 826 static void 827 Python_SaveThread(void) 828 { 829 saved_python_thread = PyEval_SaveThread(); 830 } 831 832 /* 833 * Restore a thread of the Python interpreter, waits for other threads to 834 * block. 835 */ 836 static void 837 Python_RestoreThread(void) 838 { 839 PyEval_RestoreThread(saved_python_thread); 840 saved_python_thread = NULL; 841 } 842 #endif 843 844 void 845 python_end() 846 { 847 static int recurse = 0; 848 849 /* If a crash occurs while doing this, don't try again. */ 850 if (recurse != 0) 851 return; 852 853 ++recurse; 854 855 #ifdef DYNAMIC_PYTHON 856 if (hinstPython && Py_IsInitialized()) 857 { 858 # ifdef PY_CAN_RECURSE 859 PyGILState_Ensure(); 860 # else 861 Python_RestoreThread(); /* enter python */ 862 # endif 863 Py_Finalize(); 864 } 865 end_dynamic_python(); 866 #else 867 if (Py_IsInitialized()) 868 { 869 # ifdef PY_CAN_RECURSE 870 PyGILState_Ensure(); 871 # else 872 Python_RestoreThread(); /* enter python */ 873 # endif 874 Py_Finalize(); 875 } 876 #endif 877 878 --recurse; 879 } 880 881 #if (defined(DYNAMIC_PYTHON) && defined(FEAT_PYTHON3)) || defined(PROTO) 882 int 883 python_loaded() 884 { 885 return (hinstPython != 0); 886 } 887 #endif 888 889 static int 890 Python_Init(void) 891 { 892 if (!initialised) 893 { 894 #ifdef DYNAMIC_PYTHON 895 if (!python_enabled(TRUE)) 896 { 897 EMSG(_("E263: Sorry, this command is disabled, the Python library could not be loaded.")); 898 goto fail; 899 } 900 #endif 901 902 #ifdef PYTHON_HOME 903 Py_SetPythonHome(PYTHON_HOME); 904 #endif 905 906 init_structs(); 907 908 #if !defined(MACOS) || defined(MACOS_X_UNIX) 909 Py_Initialize(); 910 #else 911 PyMac_Initialize(); 912 #endif 913 /* Initialise threads, and below save the state using 914 * PyEval_SaveThread. Without the call to PyEval_SaveThread, thread 915 * specific state (such as the system trace hook), will be lost 916 * between invocations of Python code. */ 917 PyEval_InitThreads(); 918 #ifdef DYNAMIC_PYTHON 919 get_exceptions(); 920 #endif 921 922 if (PythonIO_Init_io()) 923 goto fail; 924 925 if (PythonMod_Init()) 926 goto fail; 927 928 globals = PyModule_GetDict(PyImport_AddModule("__main__")); 929 930 /* Remove the element from sys.path that was added because of our 931 * argv[0] value in PythonMod_Init(). Previously we used an empty 932 * string, but depending on the OS we then get an empty entry or 933 * the current directory in sys.path. */ 934 PyRun_SimpleString("import sys; sys.path = filter(lambda x: x != '/must>not&exist', sys.path)"); 935 936 /* lock is created and acquired in PyEval_InitThreads() and thread 937 * state is created in Py_Initialize() 938 * there _PyGILState_NoteThreadState() also sets gilcounter to 1 939 * (python must have threads enabled!) 940 * so the following does both: unlock GIL and save thread state in TLS 941 * without deleting thread state 942 */ 943 #ifndef PY_CAN_RECURSE 944 saved_python_thread = 945 #endif 946 PyEval_SaveThread(); 947 948 initialised = 1; 949 } 950 951 return 0; 952 953 fail: 954 /* We call PythonIO_Flush() here to print any Python errors. 955 * This is OK, as it is possible to call this function even 956 * if PythonIO_Init_io() has not completed successfully (it will 957 * not do anything in this case). 958 */ 959 PythonIO_Flush(); 960 return -1; 961 } 962 963 /* 964 * External interface 965 */ 966 static void 967 DoPyCommand(const char *cmd, rangeinitializer init_range, runner run, void *arg) 968 { 969 #ifndef PY_CAN_RECURSE 970 static int recursive = 0; 971 #endif 972 #if defined(MACOS) && !defined(MACOS_X_UNIX) 973 GrafPtr oldPort; 974 #endif 975 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE) 976 char *saved_locale; 977 #endif 978 #ifdef PY_CAN_RECURSE 979 PyGILState_STATE pygilstate; 980 #endif 981 982 #ifndef PY_CAN_RECURSE 983 if (recursive) 984 { 985 EMSG(_("E659: Cannot invoke Python recursively")); 986 return; 987 } 988 ++recursive; 989 #endif 990 991 #if defined(MACOS) && !defined(MACOS_X_UNIX) 992 GetPort(&oldPort); 993 /* Check if the Python library is available */ 994 if ((Ptr)PyMac_Initialize == (Ptr)kUnresolvedCFragSymbolAddress) 995 goto theend; 996 #endif 997 if (Python_Init()) 998 goto theend; 999 1000 init_range(arg); 1001 1002 Python_Release_Vim(); /* leave vim */ 1003 1004 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE) 1005 /* Python only works properly when the LC_NUMERIC locale is "C". */ 1006 saved_locale = setlocale(LC_NUMERIC, NULL); 1007 if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0) 1008 saved_locale = NULL; 1009 else 1010 { 1011 /* Need to make a copy, value may change when setting new locale. */ 1012 saved_locale = (char *) PY_STRSAVE(saved_locale); 1013 (void)setlocale(LC_NUMERIC, "C"); 1014 } 1015 #endif 1016 1017 #ifdef PY_CAN_RECURSE 1018 pygilstate = PyGILState_Ensure(); 1019 #else 1020 Python_RestoreThread(); /* enter python */ 1021 #endif 1022 1023 run((char *) cmd, arg 1024 #ifdef PY_CAN_RECURSE 1025 , &pygilstate 1026 #endif 1027 ); 1028 1029 #ifdef PY_CAN_RECURSE 1030 PyGILState_Release(pygilstate); 1031 #else 1032 Python_SaveThread(); /* leave python */ 1033 #endif 1034 1035 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE) 1036 if (saved_locale != NULL) 1037 { 1038 (void)setlocale(LC_NUMERIC, saved_locale); 1039 PyMem_Free(saved_locale); 1040 } 1041 #endif 1042 1043 Python_Lock_Vim(); /* enter vim */ 1044 PythonIO_Flush(); 1045 #if defined(MACOS) && !defined(MACOS_X_UNIX) 1046 SetPort(oldPort); 1047 #endif 1048 1049 theend: 1050 #ifndef PY_CAN_RECURSE 1051 --recursive; 1052 #endif 1053 return; 1054 } 1055 1056 /* 1057 * ":python" 1058 */ 1059 void 1060 ex_python(exarg_T *eap) 1061 { 1062 char_u *script; 1063 1064 script = script_get(eap, eap->arg); 1065 if (!eap->skip) 1066 { 1067 DoPyCommand(script == NULL ? (char *) eap->arg : (char *) script, 1068 (rangeinitializer) init_range_cmd, 1069 (runner) run_cmd, 1070 (void *) eap); 1071 } 1072 vim_free(script); 1073 } 1074 1075 #define BUFFER_SIZE 1024 1076 1077 /* 1078 * ":pyfile" 1079 */ 1080 void 1081 ex_pyfile(exarg_T *eap) 1082 { 1083 static char buffer[BUFFER_SIZE]; 1084 const char *file = (char *)eap->arg; 1085 char *p; 1086 1087 /* Have to do it like this. PyRun_SimpleFile requires you to pass a 1088 * stdio file pointer, but Vim and the Python DLL are compiled with 1089 * different options under Windows, meaning that stdio pointers aren't 1090 * compatible between the two. Yuk. 1091 * 1092 * Put the string "execfile('file')" into buffer. But, we need to 1093 * escape any backslashes or single quotes in the file name, so that 1094 * Python won't mangle the file name. 1095 */ 1096 strcpy(buffer, "execfile('"); 1097 p = buffer + 10; /* size of "execfile('" */ 1098 1099 while (*file && p < buffer + (BUFFER_SIZE - 3)) 1100 { 1101 if (*file == '\\' || *file == '\'') 1102 *p++ = '\\'; 1103 *p++ = *file++; 1104 } 1105 1106 /* If we didn't finish the file name, we hit a buffer overflow */ 1107 if (*file != '\0') 1108 return; 1109 1110 /* Put in the terminating "')" and a null */ 1111 *p++ = '\''; 1112 *p++ = ')'; 1113 *p++ = '\0'; 1114 1115 /* Execute the file */ 1116 DoPyCommand(buffer, 1117 (rangeinitializer) init_range_cmd, 1118 (runner) run_cmd, 1119 (void *) eap); 1120 } 1121 1122 void 1123 ex_pydo(exarg_T *eap) 1124 { 1125 DoPyCommand((char *)eap->arg, 1126 (rangeinitializer) init_range_cmd, 1127 (runner)run_do, 1128 (void *)eap); 1129 } 1130 1131 /****************************************************** 1132 * 2. Python output stream: writes output via [e]msg(). 1133 */ 1134 1135 /* Implementation functions 1136 */ 1137 1138 static PyObject * 1139 OutputGetattr(PyObject *self, char *name) 1140 { 1141 if (strcmp(name, "softspace") == 0) 1142 return PyInt_FromLong(((OutputObject *)(self))->softspace); 1143 else if (strcmp(name, "__members__") == 0) 1144 return ObjectDir(NULL, OutputAttrs); 1145 1146 return Py_FindMethod(OutputMethods, self, name); 1147 } 1148 1149 /****************************************************** 1150 * 3. Implementation of the Vim module for Python 1151 */ 1152 1153 /* Window type - Implementation functions 1154 * -------------------------------------- 1155 */ 1156 1157 #define WindowType_Check(obj) ((obj)->ob_type == &WindowType) 1158 1159 /* Buffer type - Implementation functions 1160 * -------------------------------------- 1161 */ 1162 1163 #define BufferType_Check(obj) ((obj)->ob_type == &BufferType) 1164 1165 static PyInt BufferAssItem(PyObject *, PyInt, PyObject *); 1166 static PyInt BufferAssSlice(PyObject *, PyInt, PyInt, PyObject *); 1167 1168 /* Line range type - Implementation functions 1169 * -------------------------------------- 1170 */ 1171 1172 #define RangeType_Check(obj) ((obj)->ob_type == &RangeType) 1173 1174 static PyInt RangeAssItem(PyObject *, PyInt, PyObject *); 1175 static PyInt RangeAssSlice(PyObject *, PyInt, PyInt, PyObject *); 1176 1177 /* Current objects type - Implementation functions 1178 * ----------------------------------------------- 1179 */ 1180 1181 static PySequenceMethods BufferAsSeq = { 1182 (PyInquiry) BufferLength, /* sq_length, len(x) */ 1183 (binaryfunc) 0, /* BufferConcat, sq_concat, x+y */ 1184 (PyIntArgFunc) 0, /* BufferRepeat, sq_repeat, x*n */ 1185 (PyIntArgFunc) BufferItem, /* sq_item, x[i] */ 1186 (PyIntIntArgFunc) BufferSlice, /* sq_slice, x[i:j] */ 1187 (PyIntObjArgProc) BufferAssItem, /* sq_ass_item, x[i]=v */ 1188 (PyIntIntObjArgProc) BufferAssSlice, /* sq_ass_slice, x[i:j]=v */ 1189 (objobjproc) 0, 1190 (binaryfunc) 0, 1191 0, 1192 }; 1193 1194 /* Buffer object - Implementation 1195 */ 1196 1197 static PyObject * 1198 BufferGetattr(PyObject *self, char *name) 1199 { 1200 PyObject *r; 1201 1202 if ((r = BufferAttrValid((BufferObject *)(self), name))) 1203 return r; 1204 1205 if (CheckBuffer((BufferObject *)(self))) 1206 return NULL; 1207 1208 r = BufferAttr((BufferObject *)(self), name); 1209 if (r || PyErr_Occurred()) 1210 return r; 1211 else 1212 return Py_FindMethod(BufferMethods, self, name); 1213 } 1214 1215 /******************/ 1216 1217 static PyInt 1218 BufferAssItem(PyObject *self, PyInt n, PyObject *val) 1219 { 1220 return RBAsItem((BufferObject *)(self), n, val, 1, -1, NULL); 1221 } 1222 1223 static PyInt 1224 BufferAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val) 1225 { 1226 return RBAsSlice((BufferObject *)(self), lo, hi, val, 1, -1, NULL); 1227 } 1228 1229 static PySequenceMethods RangeAsSeq = { 1230 (PyInquiry) RangeLength, /* sq_length, len(x) */ 1231 (binaryfunc) 0, /* RangeConcat, */ /* sq_concat, x+y */ 1232 (PyIntArgFunc) 0, /* RangeRepeat, */ /* sq_repeat, x*n */ 1233 (PyIntArgFunc) RangeItem, /* sq_item, x[i] */ 1234 (PyIntIntArgFunc) RangeSlice, /* sq_slice, x[i:j] */ 1235 (PyIntObjArgProc) RangeAssItem, /* sq_ass_item, x[i]=v */ 1236 (PyIntIntObjArgProc) RangeAssSlice, /* sq_ass_slice, x[i:j]=v */ 1237 (objobjproc) 0, 1238 #if PY_MAJOR_VERSION >= 2 1239 (binaryfunc) 0, 1240 0, 1241 #endif 1242 }; 1243 1244 /* Line range object - Implementation 1245 */ 1246 1247 static PyObject * 1248 RangeGetattr(PyObject *self, char *name) 1249 { 1250 if (strcmp(name, "start") == 0) 1251 return Py_BuildValue(Py_ssize_t_fmt, ((RangeObject *)(self))->start - 1); 1252 else if (strcmp(name, "end") == 0) 1253 return Py_BuildValue(Py_ssize_t_fmt, ((RangeObject *)(self))->end - 1); 1254 else if (strcmp(name, "__members__") == 0) 1255 return ObjectDir(NULL, RangeAttrs); 1256 else 1257 return Py_FindMethod(RangeMethods, self, name); 1258 } 1259 1260 /****************/ 1261 1262 static PyInt 1263 RangeAssItem(PyObject *self, PyInt n, PyObject *val) 1264 { 1265 return RBAsItem(((RangeObject *)(self))->buf, n, val, 1266 ((RangeObject *)(self))->start, 1267 ((RangeObject *)(self))->end, 1268 &((RangeObject *)(self))->end); 1269 } 1270 1271 static PyInt 1272 RangeAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val) 1273 { 1274 return RBAsSlice(((RangeObject *)(self))->buf, lo, hi, val, 1275 ((RangeObject *)(self))->start, 1276 ((RangeObject *)(self))->end, 1277 &((RangeObject *)(self))->end); 1278 } 1279 1280 /* TabPage object - Implementation 1281 */ 1282 1283 static PyObject * 1284 TabPageGetattr(PyObject *self, char *name) 1285 { 1286 PyObject *r; 1287 1288 if ((r = TabPageAttrValid((TabPageObject *)(self), name))) 1289 return r; 1290 1291 if (CheckTabPage((TabPageObject *)(self))) 1292 return NULL; 1293 1294 r = TabPageAttr((TabPageObject *)(self), name); 1295 if (r || PyErr_Occurred()) 1296 return r; 1297 else 1298 return Py_FindMethod(TabPageMethods, self, name); 1299 } 1300 1301 /* Window object - Implementation 1302 */ 1303 1304 static PyObject * 1305 WindowGetattr(PyObject *self, char *name) 1306 { 1307 PyObject *r; 1308 1309 if ((r = WindowAttrValid((WindowObject *)(self), name))) 1310 return r; 1311 1312 if (CheckWindow((WindowObject *)(self))) 1313 return NULL; 1314 1315 r = WindowAttr((WindowObject *)(self), name); 1316 if (r || PyErr_Occurred()) 1317 return r; 1318 else 1319 return Py_FindMethod(WindowMethods, self, name); 1320 } 1321 1322 /* Tab page list object - Definitions 1323 */ 1324 1325 static PySequenceMethods TabListAsSeq = { 1326 (PyInquiry) TabListLength, /* sq_length, len(x) */ 1327 (binaryfunc) 0, /* sq_concat, x+y */ 1328 (PyIntArgFunc) 0, /* sq_repeat, x*n */ 1329 (PyIntArgFunc) TabListItem, /* sq_item, x[i] */ 1330 (PyIntIntArgFunc) 0, /* sq_slice, x[i:j] */ 1331 (PyIntObjArgProc) 0, /* sq_ass_item, x[i]=v */ 1332 (PyIntIntObjArgProc) 0, /* sq_ass_slice, x[i:j]=v */ 1333 (objobjproc) 0, 1334 #if PY_MAJOR_VERSION >= 2 1335 (binaryfunc) 0, 1336 0, 1337 #endif 1338 }; 1339 1340 /* Window list object - Definitions 1341 */ 1342 1343 static PySequenceMethods WinListAsSeq = { 1344 (PyInquiry) WinListLength, /* sq_length, len(x) */ 1345 (binaryfunc) 0, /* sq_concat, x+y */ 1346 (PyIntArgFunc) 0, /* sq_repeat, x*n */ 1347 (PyIntArgFunc) WinListItem, /* sq_item, x[i] */ 1348 (PyIntIntArgFunc) 0, /* sq_slice, x[i:j] */ 1349 (PyIntObjArgProc) 0, /* sq_ass_item, x[i]=v */ 1350 (PyIntIntObjArgProc) 0, /* sq_ass_slice, x[i:j]=v */ 1351 (objobjproc) 0, 1352 #if PY_MAJOR_VERSION >= 2 1353 (binaryfunc) 0, 1354 0, 1355 #endif 1356 }; 1357 1358 /* External interface 1359 */ 1360 1361 void 1362 python_buffer_free(buf_T *buf) 1363 { 1364 if (BUF_PYTHON_REF(buf) != NULL) 1365 { 1366 BufferObject *bp = BUF_PYTHON_REF(buf); 1367 bp->buf = INVALID_BUFFER_VALUE; 1368 BUF_PYTHON_REF(buf) = NULL; 1369 } 1370 } 1371 1372 #if defined(FEAT_WINDOWS) || defined(PROTO) 1373 void 1374 python_window_free(win_T *win) 1375 { 1376 if (WIN_PYTHON_REF(win) != NULL) 1377 { 1378 WindowObject *wp = WIN_PYTHON_REF(win); 1379 wp->win = INVALID_WINDOW_VALUE; 1380 WIN_PYTHON_REF(win) = NULL; 1381 } 1382 } 1383 1384 void 1385 python_tabpage_free(tabpage_T *tab) 1386 { 1387 if (TAB_PYTHON_REF(tab) != NULL) 1388 { 1389 TabPageObject *tp = TAB_PYTHON_REF(tab); 1390 tp->tab = INVALID_TABPAGE_VALUE; 1391 TAB_PYTHON_REF(tab) = NULL; 1392 } 1393 } 1394 #endif 1395 1396 static int 1397 PythonMod_Init(void) 1398 { 1399 /* The special value is removed from sys.path in Python_Init(). */ 1400 static char *(argv[2]) = {"/must>not&exist/foo", NULL}; 1401 1402 if (init_types()) 1403 return -1; 1404 1405 /* Set sys.argv[] to avoid a crash in warn(). */ 1406 PySys_SetArgv(1, argv); 1407 1408 vim_module = Py_InitModule4("vim", VimMethods, (char *)NULL, 1409 (PyObject *)NULL, PYTHON_API_VERSION); 1410 1411 if (populate_module(vim_module)) 1412 return -1; 1413 1414 if (init_sys_path()) 1415 return -1; 1416 1417 return 0; 1418 } 1419 1420 /************************************************************************* 1421 * 4. Utility functions for handling the interface between Vim and Python. 1422 */ 1423 1424 /* Convert a Vim line into a Python string. 1425 * All internal newlines are replaced by null characters. 1426 * 1427 * On errors, the Python exception data is set, and NULL is returned. 1428 */ 1429 static PyObject * 1430 LineToString(const char *str) 1431 { 1432 PyObject *result; 1433 PyInt len = strlen(str); 1434 char *p; 1435 1436 /* Allocate an Python string object, with uninitialised contents. We 1437 * must do it this way, so that we can modify the string in place 1438 * later. See the Python source, Objects/stringobject.c for details. 1439 */ 1440 result = PyString_FromStringAndSize(NULL, len); 1441 if (result == NULL) 1442 return NULL; 1443 1444 p = PyString_AsString(result); 1445 1446 while (*str) 1447 { 1448 if (*str == '\n') 1449 *p = '\0'; 1450 else 1451 *p = *str; 1452 1453 ++p; 1454 ++str; 1455 } 1456 1457 return result; 1458 } 1459 1460 static PyObject * 1461 DictionaryGetattr(PyObject *self, char *name) 1462 { 1463 DictionaryObject *this = ((DictionaryObject *) (self)); 1464 1465 if (strcmp(name, "locked") == 0) 1466 return PyInt_FromLong(this->dict->dv_lock); 1467 else if (strcmp(name, "scope") == 0) 1468 return PyInt_FromLong(this->dict->dv_scope); 1469 else if (strcmp(name, "__members__") == 0) 1470 return ObjectDir(NULL, DictionaryAttrs); 1471 1472 return Py_FindMethod(DictionaryMethods, self, name); 1473 } 1474 1475 static PySequenceMethods ListAsSeq = { 1476 (PyInquiry) ListLength, 1477 (binaryfunc) 0, 1478 (PyIntArgFunc) 0, 1479 (PyIntArgFunc) ListItem, 1480 (PyIntIntArgFunc) ListSlice, 1481 (PyIntObjArgProc) ListAssItem, 1482 (PyIntIntObjArgProc) ListAssSlice, 1483 (objobjproc) 0, 1484 #if PY_MAJOR_VERSION >= 2 1485 (binaryfunc) ListConcatInPlace, 1486 0, 1487 #endif 1488 }; 1489 1490 static PyObject * 1491 ListGetattr(PyObject *self, char *name) 1492 { 1493 if (strcmp(name, "locked") == 0) 1494 return PyInt_FromLong(((ListObject *)(self))->list->lv_lock); 1495 else if (strcmp(name, "__members__") == 0) 1496 return ObjectDir(NULL, ListAttrs); 1497 1498 return Py_FindMethod(ListMethods, self, name); 1499 } 1500 1501 static PyObject * 1502 FunctionGetattr(PyObject *self, char *name) 1503 { 1504 FunctionObject *this = (FunctionObject *)(self); 1505 1506 if (strcmp(name, "name") == 0) 1507 return PyString_FromString((char *)(this->name)); 1508 else if (strcmp(name, "__members__") == 0) 1509 return ObjectDir(NULL, FunctionAttrs); 1510 else 1511 return Py_FindMethod(FunctionMethods, self, name); 1512 } 1513 1514 void 1515 do_pyeval (char_u *str, typval_T *rettv) 1516 { 1517 DoPyCommand((char *) str, 1518 (rangeinitializer) init_range_eval, 1519 (runner) run_eval, 1520 (void *) rettv); 1521 switch(rettv->v_type) 1522 { 1523 case VAR_DICT: ++rettv->vval.v_dict->dv_refcount; break; 1524 case VAR_LIST: ++rettv->vval.v_list->lv_refcount; break; 1525 case VAR_FUNC: func_ref(rettv->vval.v_string); break; 1526 case VAR_UNKNOWN: 1527 rettv->v_type = VAR_NUMBER; 1528 rettv->vval.v_number = 0; 1529 break; 1530 } 1531 } 1532 1533 /* Don't generate a prototype for the next function, it generates an error on 1534 * newer Python versions. */ 1535 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */ && !defined(PROTO) 1536 1537 char * 1538 Py_GetProgramName(void) 1539 { 1540 return "vim"; 1541 } 1542 #endif /* Python 1.4 */ 1543 1544 void 1545 set_ref_in_python (int copyID) 1546 { 1547 set_ref_in_py(copyID); 1548 } 1549