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