1 /* vi:set ts=8 sts=4 sw=4: 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 /* 21 * Roland Puntaier 2009/sept/16: 22 * Adaptations to support both python3.x and python2.x 23 */ 24 25 /* uncomment this if used with the debug version of python */ 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 #include "vim.h" 34 35 #include <limits.h> 36 37 /* Python.h defines _POSIX_THREADS itself (if needed) */ 38 #ifdef _POSIX_THREADS 39 # undef _POSIX_THREADS 40 #endif 41 42 #if defined(_WIN32) && defined(HAVE_FCNTL_H) 43 # undef HAVE_FCNTL_H 44 #endif 45 46 #ifdef _DEBUG 47 # undef _DEBUG 48 #endif 49 50 #ifdef F_BLANK 51 # undef F_BLANK 52 #endif 53 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 /* defined in feature.h */ 58 # undef _POSIX_C_SOURCE 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(MACOS) && !defined(MACOS_X_UNIX) 69 # include "macglue.h" 70 # include <CodeFragments.h> 71 #endif 72 #undef main /* Defined in python.h - aargh */ 73 #undef HAVE_FCNTL_H /* Clash with os_win32.h */ 74 75 /* The "surrogateescape" error handler is new in Python 3.1 */ 76 #if PY_VERSION_HEX >= 0x030100f0 77 # define CODEC_ERROR_HANDLER "surrogateescape" 78 #else 79 # define CODEC_ERROR_HANDLER NULL 80 #endif 81 82 /* Python 3 does not support CObjects, always use Capsules */ 83 #define PY_USE_CAPSULE 84 85 #define PyInt Py_ssize_t 86 #define PyString_Check(obj) PyUnicode_Check(obj) 87 #define PyString_AsBytes(obj) PyUnicode_AsEncodedString(obj, (char *)ENC_OPT, CODEC_ERROR_HANDLER) 88 #define PyString_FreeBytes(obj) Py_XDECREF(bytes) 89 #define PyString_AsString(obj) PyBytes_AsString(obj) 90 #define PyString_Size(obj) PyBytes_GET_SIZE(bytes) 91 #define PyString_FromString(repr) PyUnicode_FromString(repr) 92 #define PyString_FromFormat PyUnicode_FromFormat 93 #define PyString_AsStringAndSize(obj, buffer, len) PyBytes_AsStringAndSize(obj, buffer, len) 94 #define PyInt_Check(obj) PyLong_Check(obj) 95 #define PyInt_FromLong(i) PyLong_FromLong(i) 96 #define PyInt_AsLong(obj) PyLong_AsLong(obj) 97 #define Py_ssize_t_fmt "n" 98 #define Py_bytes_fmt "y" 99 100 #if defined(DYNAMIC_PYTHON3) || defined(PROTO) 101 102 # ifndef WIN3264 103 # include <dlfcn.h> 104 # define FARPROC void* 105 # define HINSTANCE void* 106 # if defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL) 107 # define load_dll(n) dlopen((n), RTLD_LAZY) 108 # else 109 # define load_dll(n) dlopen((n), RTLD_LAZY|RTLD_GLOBAL) 110 # endif 111 # define close_dll dlclose 112 # define symbol_from_dll dlsym 113 # else 114 # define load_dll vimLoadLib 115 # define close_dll FreeLibrary 116 # define symbol_from_dll GetProcAddress 117 # endif 118 /* 119 * Wrapper defines 120 */ 121 # undef PyArg_Parse 122 # define PyArg_Parse py3_PyArg_Parse 123 # undef PyArg_ParseTuple 124 # define PyArg_ParseTuple py3_PyArg_ParseTuple 125 # define PyMem_Free py3_PyMem_Free 126 # define PyMem_Malloc py3_PyMem_Malloc 127 # define PyDict_SetItemString py3_PyDict_SetItemString 128 # define PyErr_BadArgument py3_PyErr_BadArgument 129 # define PyErr_Clear py3_PyErr_Clear 130 # define PyErr_PrintEx py3_PyErr_PrintEx 131 # define PyErr_NoMemory py3_PyErr_NoMemory 132 # define PyErr_Occurred py3_PyErr_Occurred 133 # define PyErr_PrintEx py3_PyErr_PrintEx 134 # define PyErr_SetNone py3_PyErr_SetNone 135 # define PyErr_SetString py3_PyErr_SetString 136 # define PyErr_SetObject py3_PyErr_SetObject 137 # define PyErr_ExceptionMatches py3_PyErr_ExceptionMatches 138 # define PyEval_InitThreads py3_PyEval_InitThreads 139 # define PyEval_RestoreThread py3_PyEval_RestoreThread 140 # define PyEval_SaveThread py3_PyEval_SaveThread 141 # define PyGILState_Ensure py3_PyGILState_Ensure 142 # define PyGILState_Release py3_PyGILState_Release 143 # define PyLong_AsLong py3_PyLong_AsLong 144 # define PyLong_FromLong py3_PyLong_FromLong 145 # define PyList_GetItem py3_PyList_GetItem 146 # define PyList_Append py3_PyList_Append 147 # define PyList_Insert py3_PyList_Insert 148 # define PyList_New py3_PyList_New 149 # define PyList_SetItem py3_PyList_SetItem 150 # define PyList_Size py3_PyList_Size 151 # define PySequence_Check py3_PySequence_Check 152 # define PySequence_Size py3_PySequence_Size 153 # define PySequence_GetItem py3_PySequence_GetItem 154 # define PySequence_Fast py3_PySequence_Fast 155 # define PyTuple_Size py3_PyTuple_Size 156 # define PyTuple_GetItem py3_PyTuple_GetItem 157 # define PySlice_GetIndicesEx py3_PySlice_GetIndicesEx 158 # define PyImport_ImportModule py3_PyImport_ImportModule 159 # define PyObject_Init py3__PyObject_Init 160 # define PyDict_New py3_PyDict_New 161 # define PyDict_GetItemString py3_PyDict_GetItemString 162 # define PyDict_Next py3_PyDict_Next 163 # define PyMapping_Check py3_PyMapping_Check 164 # define PyMapping_Keys py3_PyMapping_Keys 165 # define PyIter_Next py3_PyIter_Next 166 # define PyObject_GetIter py3_PyObject_GetIter 167 # define PyObject_GetItem py3_PyObject_GetItem 168 # define PyObject_IsTrue py3_PyObject_IsTrue 169 # define PyModule_GetDict py3_PyModule_GetDict 170 #undef PyRun_SimpleString 171 # define PyRun_SimpleString py3_PyRun_SimpleString 172 #undef PyRun_String 173 # define PyRun_String py3_PyRun_String 174 # define PyObject_GetAttrString py3_PyObject_GetAttrString 175 # define PyObject_HasAttrString py3_PyObject_HasAttrString 176 # define PyObject_SetAttrString py3_PyObject_SetAttrString 177 # define PyObject_CallFunctionObjArgs py3_PyObject_CallFunctionObjArgs 178 # define _PyObject_CallFunction_SizeT py3__PyObject_CallFunction_SizeT 179 # define PyObject_Call py3_PyObject_Call 180 # define PyEval_GetLocals py3_PyEval_GetLocals 181 # define PyEval_GetGlobals py3_PyEval_GetGlobals 182 # define PySys_SetObject py3_PySys_SetObject 183 # define PySys_GetObject py3_PySys_GetObject 184 # define PySys_SetArgv py3_PySys_SetArgv 185 # define PyType_Ready py3_PyType_Ready 186 #undef Py_BuildValue 187 # define Py_BuildValue py3_Py_BuildValue 188 # define Py_SetPythonHome py3_Py_SetPythonHome 189 # define Py_Initialize py3_Py_Initialize 190 # define Py_Finalize py3_Py_Finalize 191 # define Py_IsInitialized py3_Py_IsInitialized 192 # define _Py_NoneStruct (*py3__Py_NoneStruct) 193 # define _Py_FalseStruct (*py3__Py_FalseStruct) 194 # define _Py_TrueStruct (*py3__Py_TrueStruct) 195 # define _PyObject_NextNotImplemented (*py3__PyObject_NextNotImplemented) 196 # define PyModule_AddObject py3_PyModule_AddObject 197 # define PyImport_AppendInittab py3_PyImport_AppendInittab 198 # define PyImport_AddModule py3_PyImport_AddModule 199 # if PY_VERSION_HEX >= 0x030300f0 200 # undef _PyUnicode_AsString 201 # define _PyUnicode_AsString py3_PyUnicode_AsUTF8 202 # else 203 # define _PyUnicode_AsString py3__PyUnicode_AsString 204 # endif 205 # undef PyUnicode_AsEncodedString 206 # define PyUnicode_AsEncodedString py3_PyUnicode_AsEncodedString 207 # undef PyBytes_AsString 208 # define PyBytes_AsString py3_PyBytes_AsString 209 # define PyBytes_AsStringAndSize py3_PyBytes_AsStringAndSize 210 # undef PyBytes_FromString 211 # define PyBytes_FromString py3_PyBytes_FromString 212 # define PyFloat_FromDouble py3_PyFloat_FromDouble 213 # define PyFloat_AsDouble py3_PyFloat_AsDouble 214 # define PyObject_GenericGetAttr py3_PyObject_GenericGetAttr 215 # define PyType_Type (*py3_PyType_Type) 216 # define PySlice_Type (*py3_PySlice_Type) 217 # define PyFloat_Type (*py3_PyFloat_Type) 218 # define PyBool_Type (*py3_PyBool_Type) 219 # define PyErr_NewException py3_PyErr_NewException 220 # ifdef Py_DEBUG 221 # define _Py_NegativeRefcount py3__Py_NegativeRefcount 222 # define _Py_RefTotal (*py3__Py_RefTotal) 223 # define _Py_Dealloc py3__Py_Dealloc 224 # define PyModule_Create2TraceRefs py3_PyModule_Create2TraceRefs 225 # else 226 # define PyModule_Create2 py3_PyModule_Create2 227 # endif 228 # if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC) 229 # define _PyObject_DebugMalloc py3__PyObject_DebugMalloc 230 # define _PyObject_DebugFree py3__PyObject_DebugFree 231 # else 232 # define PyObject_Malloc py3_PyObject_Malloc 233 # define PyObject_Free py3_PyObject_Free 234 # endif 235 # define _PyObject_GC_New py3__PyObject_GC_New 236 # define PyObject_GC_Del py3_PyObject_GC_Del 237 # define PyObject_GC_UnTrack py3_PyObject_GC_UnTrack 238 # define PyType_GenericAlloc py3_PyType_GenericAlloc 239 # define PyType_GenericNew py3_PyType_GenericNew 240 # undef PyUnicode_FromString 241 # define PyUnicode_FromString py3_PyUnicode_FromString 242 # ifndef PyUnicode_FromFormat 243 # define PyUnicode_FromFormat py3_PyUnicode_FromFormat 244 # else 245 # define Py_UNICODE_USE_UCS_FUNCTIONS 246 # ifdef Py_UNICODE_WIDE 247 # define PyUnicodeUCS4_FromFormat py3_PyUnicodeUCS4_FromFormat 248 # else 249 # define PyUnicodeUCS2_FromFormat py3_PyUnicodeUCS2_FromFormat 250 # endif 251 # endif 252 # undef PyUnicode_Decode 253 # define PyUnicode_Decode py3_PyUnicode_Decode 254 # define PyType_IsSubtype py3_PyType_IsSubtype 255 # define PyCapsule_New py3_PyCapsule_New 256 # define PyCapsule_GetPointer py3_PyCapsule_GetPointer 257 258 # if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC) 259 # undef PyObject_NEW 260 # define PyObject_NEW(type, typeobj) \ 261 ( (type *) PyObject_Init( \ 262 (PyObject *) _PyObject_DebugMalloc( _PyObject_SIZE(typeobj) ), (typeobj)) ) 263 # endif 264 265 /* 266 * Pointers for dynamic link 267 */ 268 static int (*py3_PySys_SetArgv)(int, wchar_t **); 269 static void (*py3_Py_SetPythonHome)(wchar_t *home); 270 static void (*py3_Py_Initialize)(void); 271 static PyObject* (*py3_PyList_New)(Py_ssize_t size); 272 static PyGILState_STATE (*py3_PyGILState_Ensure)(void); 273 static void (*py3_PyGILState_Release)(PyGILState_STATE); 274 static int (*py3_PySys_SetObject)(char *, PyObject *); 275 static PyObject* (*py3_PySys_GetObject)(char *); 276 static int (*py3_PyList_Append)(PyObject *, PyObject *); 277 static int (*py3_PyList_Insert)(PyObject *, int, PyObject *); 278 static Py_ssize_t (*py3_PyList_Size)(PyObject *); 279 static int (*py3_PySequence_Check)(PyObject *); 280 static Py_ssize_t (*py3_PySequence_Size)(PyObject *); 281 static PyObject* (*py3_PySequence_GetItem)(PyObject *, Py_ssize_t); 282 static PyObject* (*py3_PySequence_Fast)(PyObject *, const char *); 283 static Py_ssize_t (*py3_PyTuple_Size)(PyObject *); 284 static PyObject* (*py3_PyTuple_GetItem)(PyObject *, Py_ssize_t); 285 static int (*py3_PyMapping_Check)(PyObject *); 286 static PyObject* (*py3_PyMapping_Keys)(PyObject *); 287 static int (*py3_PySlice_GetIndicesEx)(PyObject *r, Py_ssize_t length, 288 Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength); 289 static PyObject* (*py3_PyErr_NoMemory)(void); 290 static void (*py3_Py_Finalize)(void); 291 static void (*py3_PyErr_SetString)(PyObject *, const char *); 292 static void (*py3_PyErr_SetObject)(PyObject *, PyObject *); 293 static int (*py3_PyErr_ExceptionMatches)(PyObject *); 294 static int (*py3_PyRun_SimpleString)(char *); 295 static PyObject* (*py3_PyRun_String)(char *, int, PyObject *, PyObject *); 296 static PyObject* (*py3_PyObject_GetAttrString)(PyObject *, const char *); 297 static int (*py3_PyObject_HasAttrString)(PyObject *, const char *); 298 static PyObject* (*py3_PyObject_SetAttrString)(PyObject *, const char *, PyObject *); 299 static PyObject* (*py3_PyObject_CallFunctionObjArgs)(PyObject *, ...); 300 static PyObject* (*py3__PyObject_CallFunction_SizeT)(PyObject *, char *, ...); 301 static PyObject* (*py3_PyObject_Call)(PyObject *, PyObject *, PyObject *); 302 static PyObject* (*py3_PyEval_GetGlobals)(); 303 static PyObject* (*py3_PyEval_GetLocals)(); 304 static PyObject* (*py3_PyList_GetItem)(PyObject *, Py_ssize_t); 305 static PyObject* (*py3_PyImport_ImportModule)(const char *); 306 static PyObject* (*py3_PyImport_AddModule)(const char *); 307 static int (*py3_PyErr_BadArgument)(void); 308 static PyObject* (*py3_PyErr_Occurred)(void); 309 static PyObject* (*py3_PyModule_GetDict)(PyObject *); 310 static int (*py3_PyList_SetItem)(PyObject *, Py_ssize_t, PyObject *); 311 static PyObject* (*py3_PyDict_GetItemString)(PyObject *, const char *); 312 static int (*py3_PyDict_Next)(PyObject *, Py_ssize_t *, PyObject **, PyObject **); 313 static PyObject* (*py3_PyLong_FromLong)(long); 314 static PyObject* (*py3_PyDict_New)(void); 315 static PyObject* (*py3_PyIter_Next)(PyObject *); 316 static PyObject* (*py3_PyObject_GetIter)(PyObject *); 317 static PyObject* (*py3_PyObject_GetItem)(PyObject *, PyObject *); 318 static int (*py3_PyObject_IsTrue)(PyObject *); 319 static PyObject* (*py3_Py_BuildValue)(char *, ...); 320 static int (*py3_PyType_Ready)(PyTypeObject *type); 321 static int (*py3_PyDict_SetItemString)(PyObject *dp, char *key, PyObject *item); 322 static PyObject* (*py3_PyUnicode_FromString)(const char *u); 323 # ifndef Py_UNICODE_USE_UCS_FUNCTIONS 324 static PyObject* (*py3_PyUnicode_FromFormat)(const char *u, ...); 325 # else 326 # ifdef Py_UNICODE_WIDE 327 static PyObject* (*py3_PyUnicodeUCS4_FromFormat)(const char *u, ...); 328 # else 329 static PyObject* (*py3_PyUnicodeUCS2_FromFormat)(const char *u, ...); 330 # endif 331 # endif 332 static PyObject* (*py3_PyUnicode_Decode)(const char *u, Py_ssize_t size, 333 const char *encoding, const char *errors); 334 static long (*py3_PyLong_AsLong)(PyObject *); 335 static void (*py3_PyErr_SetNone)(PyObject *); 336 static void (*py3_PyEval_InitThreads)(void); 337 static void(*py3_PyEval_RestoreThread)(PyThreadState *); 338 static PyThreadState*(*py3_PyEval_SaveThread)(void); 339 static int (*py3_PyArg_Parse)(PyObject *, char *, ...); 340 static int (*py3_PyArg_ParseTuple)(PyObject *, char *, ...); 341 static int (*py3_PyMem_Free)(void *); 342 static void* (*py3_PyMem_Malloc)(size_t); 343 static int (*py3_Py_IsInitialized)(void); 344 static void (*py3_PyErr_Clear)(void); 345 static void (*py3_PyErr_PrintEx)(int); 346 static PyObject*(*py3__PyObject_Init)(PyObject *, PyTypeObject *); 347 static iternextfunc py3__PyObject_NextNotImplemented; 348 static PyObject* py3__Py_NoneStruct; 349 static PyObject* py3__Py_FalseStruct; 350 static PyObject* py3__Py_TrueStruct; 351 static int (*py3_PyModule_AddObject)(PyObject *m, const char *name, PyObject *o); 352 static int (*py3_PyImport_AppendInittab)(const char *name, PyObject* (*initfunc)(void)); 353 # if PY_VERSION_HEX >= 0x030300f0 354 static char* (*py3_PyUnicode_AsUTF8)(PyObject *unicode); 355 # else 356 static char* (*py3__PyUnicode_AsString)(PyObject *unicode); 357 # endif 358 static PyObject* (*py3_PyUnicode_AsEncodedString)(PyObject *unicode, const char* encoding, const char* errors); 359 static char* (*py3_PyBytes_AsString)(PyObject *bytes); 360 static int (*py3_PyBytes_AsStringAndSize)(PyObject *bytes, char **buffer, int *length); 361 static PyObject* (*py3_PyBytes_FromString)(char *str); 362 static PyObject* (*py3_PyFloat_FromDouble)(double num); 363 static double (*py3_PyFloat_AsDouble)(PyObject *); 364 static PyObject* (*py3_PyObject_GenericGetAttr)(PyObject *obj, PyObject *name); 365 static PyObject* (*py3_PyType_GenericAlloc)(PyTypeObject *type, Py_ssize_t nitems); 366 static PyObject* (*py3_PyType_GenericNew)(PyTypeObject *type, PyObject *args, PyObject *kwds); 367 static PyTypeObject* py3_PyType_Type; 368 static PyTypeObject* py3_PySlice_Type; 369 static PyTypeObject* py3_PyFloat_Type; 370 static PyTypeObject* py3_PyBool_Type; 371 static PyObject* (*py3_PyErr_NewException)(char *name, PyObject *base, PyObject *dict); 372 static PyObject* (*py3_PyCapsule_New)(void *, char *, PyCapsule_Destructor); 373 static void* (*py3_PyCapsule_GetPointer)(PyObject *, char *); 374 # ifdef Py_DEBUG 375 static void (*py3__Py_NegativeRefcount)(const char *fname, int lineno, PyObject *op); 376 static Py_ssize_t* py3__Py_RefTotal; 377 static void (*py3__Py_Dealloc)(PyObject *obj); 378 static PyObject* (*py3_PyModule_Create2TraceRefs)(struct PyModuleDef* module, int module_api_version); 379 # else 380 static PyObject* (*py3_PyModule_Create2)(struct PyModuleDef* module, int module_api_version); 381 # endif 382 # if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC) 383 static void (*py3__PyObject_DebugFree)(void*); 384 static void* (*py3__PyObject_DebugMalloc)(size_t); 385 # else 386 static void (*py3_PyObject_Free)(void*); 387 static void* (*py3_PyObject_Malloc)(size_t); 388 # endif 389 static PyObject*(*py3__PyObject_GC_New)(PyTypeObject *); 390 static void(*py3_PyObject_GC_Del)(void *); 391 static void(*py3_PyObject_GC_UnTrack)(void *); 392 static int (*py3_PyType_IsSubtype)(PyTypeObject *, PyTypeObject *); 393 394 static HINSTANCE hinstPy3 = 0; /* Instance of python.dll */ 395 396 /* Imported exception objects */ 397 static PyObject *p3imp_PyExc_AttributeError; 398 static PyObject *p3imp_PyExc_IndexError; 399 static PyObject *p3imp_PyExc_KeyError; 400 static PyObject *p3imp_PyExc_KeyboardInterrupt; 401 static PyObject *p3imp_PyExc_TypeError; 402 static PyObject *p3imp_PyExc_ValueError; 403 static PyObject *p3imp_PyExc_RuntimeError; 404 static PyObject *p3imp_PyExc_ImportError; 405 406 # define PyExc_AttributeError p3imp_PyExc_AttributeError 407 # define PyExc_IndexError p3imp_PyExc_IndexError 408 # define PyExc_KeyError p3imp_PyExc_KeyError 409 # define PyExc_KeyboardInterrupt p3imp_PyExc_KeyboardInterrupt 410 # define PyExc_TypeError p3imp_PyExc_TypeError 411 # define PyExc_ValueError p3imp_PyExc_ValueError 412 # define PyExc_RuntimeError p3imp_PyExc_RuntimeError 413 # define PyExc_ImportError p3imp_PyExc_ImportError 414 415 /* 416 * Table of name to function pointer of python. 417 */ 418 # define PYTHON_PROC FARPROC 419 static struct 420 { 421 char *name; 422 PYTHON_PROC *ptr; 423 } py3_funcname_table[] = 424 { 425 {"PySys_SetArgv", (PYTHON_PROC*)&py3_PySys_SetArgv}, 426 {"Py_SetPythonHome", (PYTHON_PROC*)&py3_Py_SetPythonHome}, 427 {"Py_Initialize", (PYTHON_PROC*)&py3_Py_Initialize}, 428 # ifndef PY_SSIZE_T_CLEAN 429 {"PyArg_ParseTuple", (PYTHON_PROC*)&py3_PyArg_ParseTuple}, 430 {"Py_BuildValue", (PYTHON_PROC*)&py3_Py_BuildValue}, 431 # else 432 {"_PyArg_ParseTuple_SizeT", (PYTHON_PROC*)&py3_PyArg_ParseTuple}, 433 {"_Py_BuildValue_SizeT", (PYTHON_PROC*)&py3_Py_BuildValue}, 434 # endif 435 {"PyMem_Free", (PYTHON_PROC*)&py3_PyMem_Free}, 436 {"PyMem_Malloc", (PYTHON_PROC*)&py3_PyMem_Malloc}, 437 {"PyList_New", (PYTHON_PROC*)&py3_PyList_New}, 438 {"PyGILState_Ensure", (PYTHON_PROC*)&py3_PyGILState_Ensure}, 439 {"PyGILState_Release", (PYTHON_PROC*)&py3_PyGILState_Release}, 440 {"PySys_SetObject", (PYTHON_PROC*)&py3_PySys_SetObject}, 441 {"PySys_GetObject", (PYTHON_PROC*)&py3_PySys_GetObject}, 442 {"PyList_Append", (PYTHON_PROC*)&py3_PyList_Append}, 443 {"PyList_Insert", (PYTHON_PROC*)&py3_PyList_Insert}, 444 {"PyList_Size", (PYTHON_PROC*)&py3_PyList_Size}, 445 {"PySequence_Check", (PYTHON_PROC*)&py3_PySequence_Check}, 446 {"PySequence_Size", (PYTHON_PROC*)&py3_PySequence_Size}, 447 {"PySequence_GetItem", (PYTHON_PROC*)&py3_PySequence_GetItem}, 448 {"PySequence_Fast", (PYTHON_PROC*)&py3_PySequence_Fast}, 449 {"PyTuple_Size", (PYTHON_PROC*)&py3_PyTuple_Size}, 450 {"PyTuple_GetItem", (PYTHON_PROC*)&py3_PyTuple_GetItem}, 451 {"PySlice_GetIndicesEx", (PYTHON_PROC*)&py3_PySlice_GetIndicesEx}, 452 {"PyErr_NoMemory", (PYTHON_PROC*)&py3_PyErr_NoMemory}, 453 {"Py_Finalize", (PYTHON_PROC*)&py3_Py_Finalize}, 454 {"PyErr_SetString", (PYTHON_PROC*)&py3_PyErr_SetString}, 455 {"PyErr_SetObject", (PYTHON_PROC*)&py3_PyErr_SetObject}, 456 {"PyErr_ExceptionMatches", (PYTHON_PROC*)&py3_PyErr_ExceptionMatches}, 457 {"PyRun_SimpleString", (PYTHON_PROC*)&py3_PyRun_SimpleString}, 458 {"PyRun_String", (PYTHON_PROC*)&py3_PyRun_String}, 459 {"PyObject_GetAttrString", (PYTHON_PROC*)&py3_PyObject_GetAttrString}, 460 {"PyObject_HasAttrString", (PYTHON_PROC*)&py3_PyObject_HasAttrString}, 461 {"PyObject_SetAttrString", (PYTHON_PROC*)&py3_PyObject_SetAttrString}, 462 {"PyObject_CallFunctionObjArgs", (PYTHON_PROC*)&py3_PyObject_CallFunctionObjArgs}, 463 {"_PyObject_CallFunction_SizeT", (PYTHON_PROC*)&py3__PyObject_CallFunction_SizeT}, 464 {"PyObject_Call", (PYTHON_PROC*)&py3_PyObject_Call}, 465 {"PyEval_GetGlobals", (PYTHON_PROC*)&py3_PyEval_GetGlobals}, 466 {"PyEval_GetLocals", (PYTHON_PROC*)&py3_PyEval_GetLocals}, 467 {"PyList_GetItem", (PYTHON_PROC*)&py3_PyList_GetItem}, 468 {"PyImport_ImportModule", (PYTHON_PROC*)&py3_PyImport_ImportModule}, 469 {"PyImport_AddModule", (PYTHON_PROC*)&py3_PyImport_AddModule}, 470 {"PyErr_BadArgument", (PYTHON_PROC*)&py3_PyErr_BadArgument}, 471 {"PyErr_Occurred", (PYTHON_PROC*)&py3_PyErr_Occurred}, 472 {"PyModule_GetDict", (PYTHON_PROC*)&py3_PyModule_GetDict}, 473 {"PyList_SetItem", (PYTHON_PROC*)&py3_PyList_SetItem}, 474 {"PyDict_GetItemString", (PYTHON_PROC*)&py3_PyDict_GetItemString}, 475 {"PyDict_Next", (PYTHON_PROC*)&py3_PyDict_Next}, 476 {"PyMapping_Check", (PYTHON_PROC*)&py3_PyMapping_Check}, 477 {"PyMapping_Keys", (PYTHON_PROC*)&py3_PyMapping_Keys}, 478 {"PyIter_Next", (PYTHON_PROC*)&py3_PyIter_Next}, 479 {"PyObject_GetIter", (PYTHON_PROC*)&py3_PyObject_GetIter}, 480 {"PyObject_GetItem", (PYTHON_PROC*)&py3_PyObject_GetItem}, 481 {"PyObject_IsTrue", (PYTHON_PROC*)&py3_PyObject_IsTrue}, 482 {"PyLong_FromLong", (PYTHON_PROC*)&py3_PyLong_FromLong}, 483 {"PyDict_New", (PYTHON_PROC*)&py3_PyDict_New}, 484 {"PyType_Ready", (PYTHON_PROC*)&py3_PyType_Ready}, 485 {"PyDict_SetItemString", (PYTHON_PROC*)&py3_PyDict_SetItemString}, 486 {"PyLong_AsLong", (PYTHON_PROC*)&py3_PyLong_AsLong}, 487 {"PyErr_SetNone", (PYTHON_PROC*)&py3_PyErr_SetNone}, 488 {"PyEval_InitThreads", (PYTHON_PROC*)&py3_PyEval_InitThreads}, 489 {"PyEval_RestoreThread", (PYTHON_PROC*)&py3_PyEval_RestoreThread}, 490 {"PyEval_SaveThread", (PYTHON_PROC*)&py3_PyEval_SaveThread}, 491 {"PyArg_Parse", (PYTHON_PROC*)&py3_PyArg_Parse}, 492 {"Py_IsInitialized", (PYTHON_PROC*)&py3_Py_IsInitialized}, 493 {"_PyObject_NextNotImplemented", (PYTHON_PROC*)&py3__PyObject_NextNotImplemented}, 494 {"_Py_NoneStruct", (PYTHON_PROC*)&py3__Py_NoneStruct}, 495 {"_Py_FalseStruct", (PYTHON_PROC*)&py3__Py_FalseStruct}, 496 {"_Py_TrueStruct", (PYTHON_PROC*)&py3__Py_TrueStruct}, 497 {"PyErr_Clear", (PYTHON_PROC*)&py3_PyErr_Clear}, 498 {"PyErr_PrintEx", (PYTHON_PROC*)&py3_PyErr_PrintEx}, 499 {"PyObject_Init", (PYTHON_PROC*)&py3__PyObject_Init}, 500 {"PyModule_AddObject", (PYTHON_PROC*)&py3_PyModule_AddObject}, 501 {"PyImport_AppendInittab", (PYTHON_PROC*)&py3_PyImport_AppendInittab}, 502 # if PY_VERSION_HEX >= 0x030300f0 503 {"PyUnicode_AsUTF8", (PYTHON_PROC*)&py3_PyUnicode_AsUTF8}, 504 # else 505 {"_PyUnicode_AsString", (PYTHON_PROC*)&py3__PyUnicode_AsString}, 506 # endif 507 # ifndef Py_UNICODE_USE_UCS_FUNCTIONS 508 {"PyUnicode_FromFormat", (PYTHON_PROC*)&py3_PyUnicode_FromFormat}, 509 # else 510 # ifdef Py_UNICODE_WIDE 511 {"PyUnicodeUCS4_FromFormat", (PYTHON_PROC*)&py3_PyUnicodeUCS4_FromFormat}, 512 # else 513 {"PyUnicodeUCS2_FromFormat", (PYTHON_PROC*)&py3_PyUnicodeUCS2_FromFormat}, 514 # endif 515 # endif 516 {"PyBytes_AsString", (PYTHON_PROC*)&py3_PyBytes_AsString}, 517 {"PyBytes_AsStringAndSize", (PYTHON_PROC*)&py3_PyBytes_AsStringAndSize}, 518 {"PyBytes_FromString", (PYTHON_PROC*)&py3_PyBytes_FromString}, 519 {"PyFloat_FromDouble", (PYTHON_PROC*)&py3_PyFloat_FromDouble}, 520 {"PyFloat_AsDouble", (PYTHON_PROC*)&py3_PyFloat_AsDouble}, 521 {"PyObject_GenericGetAttr", (PYTHON_PROC*)&py3_PyObject_GenericGetAttr}, 522 {"PyType_GenericAlloc", (PYTHON_PROC*)&py3_PyType_GenericAlloc}, 523 {"PyType_GenericNew", (PYTHON_PROC*)&py3_PyType_GenericNew}, 524 {"PyType_Type", (PYTHON_PROC*)&py3_PyType_Type}, 525 {"PySlice_Type", (PYTHON_PROC*)&py3_PySlice_Type}, 526 {"PyFloat_Type", (PYTHON_PROC*)&py3_PyFloat_Type}, 527 {"PyBool_Type", (PYTHON_PROC*)&py3_PyBool_Type}, 528 {"PyErr_NewException", (PYTHON_PROC*)&py3_PyErr_NewException}, 529 # ifdef Py_DEBUG 530 {"_Py_NegativeRefcount", (PYTHON_PROC*)&py3__Py_NegativeRefcount}, 531 {"_Py_RefTotal", (PYTHON_PROC*)&py3__Py_RefTotal}, 532 {"_Py_Dealloc", (PYTHON_PROC*)&py3__Py_Dealloc}, 533 {"PyModule_Create2TraceRefs", (PYTHON_PROC*)&py3_PyModule_Create2TraceRefs}, 534 # else 535 {"PyModule_Create2", (PYTHON_PROC*)&py3_PyModule_Create2}, 536 # endif 537 # if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC) 538 {"_PyObject_DebugFree", (PYTHON_PROC*)&py3__PyObject_DebugFree}, 539 {"_PyObject_DebugMalloc", (PYTHON_PROC*)&py3__PyObject_DebugMalloc}, 540 # else 541 {"PyObject_Malloc", (PYTHON_PROC*)&py3_PyObject_Malloc}, 542 {"PyObject_Free", (PYTHON_PROC*)&py3_PyObject_Free}, 543 # endif 544 {"_PyObject_GC_New", (PYTHON_PROC*)&py3__PyObject_GC_New}, 545 {"PyObject_GC_Del", (PYTHON_PROC*)&py3_PyObject_GC_Del}, 546 {"PyObject_GC_UnTrack", (PYTHON_PROC*)&py3_PyObject_GC_UnTrack}, 547 {"PyType_IsSubtype", (PYTHON_PROC*)&py3_PyType_IsSubtype}, 548 {"PyCapsule_New", (PYTHON_PROC*)&py3_PyCapsule_New}, 549 {"PyCapsule_GetPointer", (PYTHON_PROC*)&py3_PyCapsule_GetPointer}, 550 {"", NULL}, 551 }; 552 553 /* 554 * Free python.dll 555 */ 556 static void 557 end_dynamic_python3(void) 558 { 559 if (hinstPy3 != 0) 560 { 561 close_dll(hinstPy3); 562 hinstPy3 = 0; 563 } 564 } 565 566 /* 567 * Load library and get all pointers. 568 * Parameter 'libname' provides name of DLL. 569 * Return OK or FAIL. 570 */ 571 static int 572 py3_runtime_link_init(char *libname, int verbose) 573 { 574 int i; 575 void *ucs_from_string, *ucs_decode, *ucs_as_encoded_string; 576 577 # if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON) 578 /* Can't have Python and Python3 loaded at the same time. 579 * It cause a crash, because RTLD_GLOBAL is needed for 580 * standard C extension libraries of one or both python versions. */ 581 if (python_loaded()) 582 { 583 if (verbose) 584 EMSG(_("E837: This Vim cannot execute :py3 after using :python")); 585 return FAIL; 586 } 587 # endif 588 589 if (hinstPy3 != 0) 590 return OK; 591 hinstPy3 = load_dll(libname); 592 593 if (!hinstPy3) 594 { 595 if (verbose) 596 EMSG2(_(e_loadlib), libname); 597 return FAIL; 598 } 599 600 for (i = 0; py3_funcname_table[i].ptr; ++i) 601 { 602 if ((*py3_funcname_table[i].ptr = symbol_from_dll(hinstPy3, 603 py3_funcname_table[i].name)) == NULL) 604 { 605 close_dll(hinstPy3); 606 hinstPy3 = 0; 607 if (verbose) 608 EMSG2(_(e_loadfunc), py3_funcname_table[i].name); 609 return FAIL; 610 } 611 } 612 613 /* Load unicode functions separately as only the ucs2 or the ucs4 functions 614 * will be present in the library. */ 615 # if PY_VERSION_HEX >= 0x030300f0 616 ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicode_FromString"); 617 ucs_decode = symbol_from_dll(hinstPy3, "PyUnicode_Decode"); 618 ucs_as_encoded_string = symbol_from_dll(hinstPy3, 619 "PyUnicode_AsEncodedString"); 620 # else 621 ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicodeUCS2_FromString"); 622 ucs_decode = symbol_from_dll(hinstPy3, 623 "PyUnicodeUCS2_Decode"); 624 ucs_as_encoded_string = symbol_from_dll(hinstPy3, 625 "PyUnicodeUCS2_AsEncodedString"); 626 if (!ucs_from_string || !ucs_decode || !ucs_as_encoded_string) 627 { 628 ucs_from_string = symbol_from_dll(hinstPy3, 629 "PyUnicodeUCS4_FromString"); 630 ucs_decode = symbol_from_dll(hinstPy3, 631 "PyUnicodeUCS4_Decode"); 632 ucs_as_encoded_string = symbol_from_dll(hinstPy3, 633 "PyUnicodeUCS4_AsEncodedString"); 634 } 635 # endif 636 if (ucs_from_string && ucs_decode && ucs_as_encoded_string) 637 { 638 py3_PyUnicode_FromString = ucs_from_string; 639 py3_PyUnicode_Decode = ucs_decode; 640 py3_PyUnicode_AsEncodedString = ucs_as_encoded_string; 641 } 642 else 643 { 644 close_dll(hinstPy3); 645 hinstPy3 = 0; 646 if (verbose) 647 EMSG2(_(e_loadfunc), "PyUnicode_UCSX_*"); 648 return FAIL; 649 } 650 651 return OK; 652 } 653 654 /* 655 * If python is enabled (there is installed python on Windows system) return 656 * TRUE, else FALSE. 657 */ 658 int 659 python3_enabled(int verbose) 660 { 661 return py3_runtime_link_init(DYNAMIC_PYTHON3_DLL, verbose) == OK; 662 } 663 664 /* Load the standard Python exceptions - don't import the symbols from the 665 * DLL, as this can cause errors (importing data symbols is not reliable). 666 */ 667 static void get_py3_exceptions __ARGS((void)); 668 669 static void 670 get_py3_exceptions() 671 { 672 PyObject *exmod = PyImport_ImportModule("builtins"); 673 PyObject *exdict = PyModule_GetDict(exmod); 674 p3imp_PyExc_AttributeError = PyDict_GetItemString(exdict, "AttributeError"); 675 p3imp_PyExc_IndexError = PyDict_GetItemString(exdict, "IndexError"); 676 p3imp_PyExc_KeyError = PyDict_GetItemString(exdict, "KeyError"); 677 p3imp_PyExc_KeyboardInterrupt = PyDict_GetItemString(exdict, "KeyboardInterrupt"); 678 p3imp_PyExc_TypeError = PyDict_GetItemString(exdict, "TypeError"); 679 p3imp_PyExc_ValueError = PyDict_GetItemString(exdict, "ValueError"); 680 p3imp_PyExc_RuntimeError = PyDict_GetItemString(exdict, "RuntimeError"); 681 p3imp_PyExc_ImportError = PyDict_GetItemString(exdict, "ImportError"); 682 Py_XINCREF(p3imp_PyExc_AttributeError); 683 Py_XINCREF(p3imp_PyExc_IndexError); 684 Py_XINCREF(p3imp_PyExc_KeyError); 685 Py_XINCREF(p3imp_PyExc_KeyboardInterrupt); 686 Py_XINCREF(p3imp_PyExc_TypeError); 687 Py_XINCREF(p3imp_PyExc_ValueError); 688 Py_XINCREF(p3imp_PyExc_RuntimeError); 689 Py_XINCREF(p3imp_PyExc_ImportError); 690 Py_XDECREF(exmod); 691 } 692 #endif /* DYNAMIC_PYTHON3 */ 693 694 static int py3initialised = 0; 695 696 #define PYINITIALISED py3initialised 697 698 #define DESTRUCTOR_FINISH(self) Py_TYPE(self)->tp_free((PyObject*)self) 699 700 #define WIN_PYTHON_REF(win) win->w_python3_ref 701 #define BUF_PYTHON_REF(buf) buf->b_python3_ref 702 #define TAB_PYTHON_REF(tab) tab->tp_python3_ref 703 704 static void 705 call_PyObject_Free(void *p) 706 { 707 #if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC) 708 _PyObject_DebugFree(p); 709 #else 710 PyObject_Free(p); 711 #endif 712 } 713 714 static PyObject * 715 call_PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds) 716 { 717 return PyType_GenericNew(type,args,kwds); 718 } 719 720 static PyObject * 721 call_PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) 722 { 723 return PyType_GenericAlloc(type,nitems); 724 } 725 726 static PyObject *OutputGetattro(PyObject *, PyObject *); 727 static int OutputSetattro(PyObject *, PyObject *, PyObject *); 728 static PyObject *BufferGetattro(PyObject *, PyObject *); 729 static int BufferSetattro(PyObject *, PyObject *, PyObject *); 730 static PyObject *TabPageGetattro(PyObject *, PyObject *); 731 static PyObject *WindowGetattro(PyObject *, PyObject *); 732 static int WindowSetattro(PyObject *, PyObject *, PyObject *); 733 static PyObject *RangeGetattro(PyObject *, PyObject *); 734 static PyObject *CurrentGetattro(PyObject *, PyObject *); 735 static int CurrentSetattro(PyObject *, PyObject *, PyObject *); 736 static PyObject *DictionaryGetattro(PyObject *, PyObject *); 737 static int DictionarySetattro(PyObject *, PyObject *, PyObject *); 738 static PyObject *ListGetattro(PyObject *, PyObject *); 739 static int ListSetattro(PyObject *, PyObject *, PyObject *); 740 static PyObject *FunctionGetattro(PyObject *, PyObject *); 741 742 static PyObject *VimPathHook(PyObject *, PyObject *); 743 744 static struct PyModuleDef vimmodule; 745 746 #define PY_CAN_RECURSE 747 748 /* 749 * Include the code shared with if_python.c 750 */ 751 #include "if_py_both.h" 752 753 #define GET_ATTR_STRING(name, nameobj) \ 754 char *name = ""; \ 755 if (PyUnicode_Check(nameobj)) \ 756 name = _PyUnicode_AsString(nameobj) 757 758 #define PY3OBJ_DELETED(obj) (obj->ob_base.ob_refcnt<=0) 759 760 /****************************************************** 761 * Internal function prototypes. 762 */ 763 764 static PyObject *Py3Init_vim(void); 765 766 /****************************************************** 767 * 1. Python interpreter main program. 768 */ 769 770 void 771 python3_end() 772 { 773 static int recurse = 0; 774 775 /* If a crash occurs while doing this, don't try again. */ 776 if (recurse != 0) 777 return; 778 779 ++recurse; 780 781 #ifdef DYNAMIC_PYTHON3 782 if (hinstPy3) 783 #endif 784 if (Py_IsInitialized()) 785 { 786 // acquire lock before finalizing 787 PyGILState_Ensure(); 788 789 Py_Finalize(); 790 } 791 792 #ifdef DYNAMIC_PYTHON3 793 end_dynamic_python3(); 794 #endif 795 796 --recurse; 797 } 798 799 #if (defined(DYNAMIC_PYTHON) && defined(FEAT_PYTHON)) || defined(PROTO) 800 int 801 python3_loaded() 802 { 803 return (hinstPy3 != 0); 804 } 805 #endif 806 807 static int 808 Python3_Init(void) 809 { 810 if (!py3initialised) 811 { 812 #ifdef DYNAMIC_PYTHON3 813 if (!python3_enabled(TRUE)) 814 { 815 EMSG(_("E263: Sorry, this command is disabled, the Python library could not be loaded.")); 816 goto fail; 817 } 818 #endif 819 820 init_structs(); 821 822 823 #ifdef PYTHON3_HOME 824 Py_SetPythonHome(PYTHON3_HOME); 825 #endif 826 827 PyImport_AppendInittab("vim", Py3Init_vim); 828 829 #if !defined(MACOS) || defined(MACOS_X_UNIX) 830 Py_Initialize(); 831 #else 832 PyMac_Initialize(); 833 #endif 834 /* Initialise threads, and below save the state using 835 * PyEval_SaveThread. Without the call to PyEval_SaveThread, thread 836 * specific state (such as the system trace hook), will be lost 837 * between invocations of Python code. */ 838 PyEval_InitThreads(); 839 #ifdef DYNAMIC_PYTHON3 840 get_py3_exceptions(); 841 #endif 842 843 if (PythonIO_Init_io()) 844 goto fail; 845 846 globals = PyModule_GetDict(PyImport_AddModule("__main__")); 847 848 /* Remove the element from sys.path that was added because of our 849 * argv[0] value in Py3Init_vim(). Previously we used an empty 850 * string, but depending on the OS we then get an empty entry or 851 * the current directory in sys.path. 852 * Only after vim has been imported, the element does exist in 853 * sys.path. 854 */ 855 PyRun_SimpleString("import vim; import sys; sys.path = list(filter(lambda x: not x.endswith('must>not&exist'), sys.path))"); 856 857 /* lock is created and acquired in PyEval_InitThreads() and thread 858 * state is created in Py_Initialize() 859 * there _PyGILState_NoteThreadState() also sets gilcounter to 1 860 * (python must have threads enabled!) 861 * so the following does both: unlock GIL and save thread state in TLS 862 * without deleting thread state 863 */ 864 PyEval_SaveThread(); 865 866 py3initialised = 1; 867 } 868 869 return 0; 870 871 fail: 872 /* We call PythonIO_Flush() here to print any Python errors. 873 * This is OK, as it is possible to call this function even 874 * if PythonIO_Init_io() has not completed successfully (it will 875 * not do anything in this case). 876 */ 877 PythonIO_Flush(); 878 return -1; 879 } 880 881 /* 882 * External interface 883 */ 884 static void 885 DoPyCommand(const char *cmd, rangeinitializer init_range, runner run, void *arg) 886 { 887 #if defined(MACOS) && !defined(MACOS_X_UNIX) 888 GrafPtr oldPort; 889 #endif 890 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE) 891 char *saved_locale; 892 #endif 893 PyObject *cmdstr; 894 PyObject *cmdbytes; 895 PyGILState_STATE pygilstate; 896 897 #if defined(MACOS) && !defined(MACOS_X_UNIX) 898 GetPort(&oldPort); 899 /* Check if the Python library is available */ 900 if ((Ptr)PyMac_Initialize == (Ptr)kUnresolvedCFragSymbolAddress) 901 goto theend; 902 #endif 903 if (Python3_Init()) 904 goto theend; 905 906 init_range(arg); 907 908 Python_Release_Vim(); /* leave vim */ 909 910 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE) 911 /* Python only works properly when the LC_NUMERIC locale is "C". */ 912 saved_locale = setlocale(LC_NUMERIC, NULL); 913 if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0) 914 saved_locale = NULL; 915 else 916 { 917 /* Need to make a copy, value may change when setting new locale. */ 918 saved_locale = (char *)vim_strsave((char_u *)saved_locale); 919 (void)setlocale(LC_NUMERIC, "C"); 920 } 921 #endif 922 923 pygilstate = PyGILState_Ensure(); 924 925 /* PyRun_SimpleString expects a UTF-8 string. Wrong encoding may cause 926 * SyntaxError (unicode error). */ 927 cmdstr = PyUnicode_Decode(cmd, strlen(cmd), 928 (char *)ENC_OPT, CODEC_ERROR_HANDLER); 929 cmdbytes = PyUnicode_AsEncodedString(cmdstr, "utf-8", CODEC_ERROR_HANDLER); 930 Py_XDECREF(cmdstr); 931 932 run(PyBytes_AsString(cmdbytes), arg, &pygilstate); 933 Py_XDECREF(cmdbytes); 934 935 PyGILState_Release(pygilstate); 936 937 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE) 938 if (saved_locale != NULL) 939 { 940 (void)setlocale(LC_NUMERIC, saved_locale); 941 vim_free(saved_locale); 942 } 943 #endif 944 945 Python_Lock_Vim(); /* enter vim */ 946 PythonIO_Flush(); 947 #if defined(MACOS) && !defined(MACOS_X_UNIX) 948 SetPort(oldPort); 949 #endif 950 951 theend: 952 return; /* keeps lint happy */ 953 } 954 955 /* 956 * ":py3" 957 */ 958 void 959 ex_py3(exarg_T *eap) 960 { 961 char_u *script; 962 963 script = script_get(eap, eap->arg); 964 if (!eap->skip) 965 { 966 DoPyCommand(script == NULL ? (char *) eap->arg : (char *) script, 967 (rangeinitializer) init_range_cmd, 968 (runner) run_cmd, 969 (void *) eap); 970 } 971 vim_free(script); 972 } 973 974 #define BUFFER_SIZE 2048 975 976 /* 977 * ":py3file" 978 */ 979 void 980 ex_py3file(exarg_T *eap) 981 { 982 static char buffer[BUFFER_SIZE]; 983 const char *file; 984 char *p; 985 int i; 986 987 /* Have to do it like this. PyRun_SimpleFile requires you to pass a 988 * stdio file pointer, but Vim and the Python DLL are compiled with 989 * different options under Windows, meaning that stdio pointers aren't 990 * compatible between the two. Yuk. 991 * 992 * construct: exec(compile(open('a_filename', 'rb').read(), 'a_filename', 'exec')) 993 * 994 * Using bytes so that Python can detect the source encoding as it normally 995 * does. The doc does not say "compile" accept bytes, though. 996 * 997 * We need to escape any backslashes or single quotes in the file name, so that 998 * Python won't mangle the file name. 999 */ 1000 1001 strcpy(buffer, "exec(compile(open('"); 1002 p = buffer + 19; /* size of "exec(compile(open('" */ 1003 1004 for (i=0; i<2; ++i) 1005 { 1006 file = (char *)eap->arg; 1007 while (*file && p < buffer + (BUFFER_SIZE - 3)) 1008 { 1009 if (*file == '\\' || *file == '\'') 1010 *p++ = '\\'; 1011 *p++ = *file++; 1012 } 1013 /* If we didn't finish the file name, we hit a buffer overflow */ 1014 if (*file != '\0') 1015 return; 1016 if (i==0) 1017 { 1018 strcpy(p,"','rb').read(),'"); 1019 p += 16; 1020 } 1021 else 1022 { 1023 strcpy(p,"','exec'))"); 1024 p += 10; 1025 } 1026 } 1027 1028 1029 /* Execute the file */ 1030 DoPyCommand(buffer, 1031 (rangeinitializer) init_range_cmd, 1032 (runner) run_cmd, 1033 (void *) eap); 1034 } 1035 1036 void 1037 ex_py3do(exarg_T *eap) 1038 { 1039 DoPyCommand((char *)eap->arg, 1040 (rangeinitializer)init_range_cmd, 1041 (runner)run_do, 1042 (void *)eap); 1043 } 1044 1045 /****************************************************** 1046 * 2. Python output stream: writes output via [e]msg(). 1047 */ 1048 1049 /* Implementation functions 1050 */ 1051 1052 static PyObject * 1053 OutputGetattro(PyObject *self, PyObject *nameobj) 1054 { 1055 GET_ATTR_STRING(name, nameobj); 1056 1057 if (strcmp(name, "softspace") == 0) 1058 return PyLong_FromLong(((OutputObject *)(self))->softspace); 1059 1060 return PyObject_GenericGetAttr(self, nameobj); 1061 } 1062 1063 static int 1064 OutputSetattro(PyObject *self, PyObject *nameobj, PyObject *val) 1065 { 1066 GET_ATTR_STRING(name, nameobj); 1067 1068 return OutputSetattr((OutputObject *)(self), name, val); 1069 } 1070 1071 /****************************************************** 1072 * 3. Implementation of the Vim module for Python 1073 */ 1074 1075 /* Window type - Implementation functions 1076 * -------------------------------------- 1077 */ 1078 1079 #define WindowType_Check(obj) ((obj)->ob_base.ob_type == &WindowType) 1080 1081 /* Buffer type - Implementation functions 1082 * -------------------------------------- 1083 */ 1084 1085 #define BufferType_Check(obj) ((obj)->ob_base.ob_type == &BufferType) 1086 1087 static PyObject* BufferSubscript(PyObject *self, PyObject *idx); 1088 static Py_ssize_t BufferAsSubscript(PyObject *self, PyObject *idx, PyObject *val); 1089 1090 /* Line range type - Implementation functions 1091 * -------------------------------------- 1092 */ 1093 1094 #define RangeType_Check(obj) ((obj)->ob_base.ob_type == &RangeType) 1095 1096 static PyObject* RangeSubscript(PyObject *self, PyObject *idx); 1097 static Py_ssize_t RangeAsItem(PyObject *, Py_ssize_t, PyObject *); 1098 static Py_ssize_t RangeAsSubscript(PyObject *self, PyObject *idx, PyObject *val); 1099 1100 /* Current objects type - Implementation functions 1101 * ----------------------------------------------- 1102 */ 1103 1104 static PySequenceMethods BufferAsSeq = { 1105 (lenfunc) BufferLength, /* sq_length, len(x) */ 1106 (binaryfunc) 0, /* sq_concat, x+y */ 1107 (ssizeargfunc) 0, /* sq_repeat, x*n */ 1108 (ssizeargfunc) BufferItem, /* sq_item, x[i] */ 1109 0, /* was_sq_slice, x[i:j] */ 1110 0, /* sq_ass_item, x[i]=v */ 1111 0, /* sq_ass_slice, x[i:j]=v */ 1112 0, /* sq_contains */ 1113 0, /* sq_inplace_concat */ 1114 0, /* sq_inplace_repeat */ 1115 }; 1116 1117 static PyMappingMethods BufferAsMapping = { 1118 /* mp_length */ (lenfunc)BufferLength, 1119 /* mp_subscript */ (binaryfunc)BufferSubscript, 1120 /* mp_ass_subscript */ (objobjargproc)BufferAsSubscript, 1121 }; 1122 1123 1124 /* Buffer object 1125 */ 1126 1127 static PyObject * 1128 BufferGetattro(PyObject *self, PyObject *nameobj) 1129 { 1130 PyObject *r; 1131 1132 GET_ATTR_STRING(name, nameobj); 1133 1134 if ((r = BufferAttrValid((BufferObject *)(self), name))) 1135 return r; 1136 1137 if (CheckBuffer((BufferObject *)(self))) 1138 return NULL; 1139 1140 r = BufferAttr((BufferObject *)(self), name); 1141 if (r || PyErr_Occurred()) 1142 return r; 1143 else 1144 return PyObject_GenericGetAttr(self, nameobj); 1145 } 1146 1147 static int 1148 BufferSetattro(PyObject *self, PyObject *nameobj, PyObject *val) 1149 { 1150 GET_ATTR_STRING(name, nameobj); 1151 1152 return BufferSetattr((BufferObject *)(self), name, val); 1153 } 1154 1155 /******************/ 1156 1157 static PyObject * 1158 BufferSubscript(PyObject *self, PyObject* idx) 1159 { 1160 if (PyLong_Check(idx)) 1161 { 1162 long _idx = PyLong_AsLong(idx); 1163 return BufferItem((BufferObject *)(self), _idx); 1164 } else if (PySlice_Check(idx)) 1165 { 1166 Py_ssize_t start, stop, step, slicelen; 1167 1168 if (CheckBuffer((BufferObject *) self)) 1169 return NULL; 1170 1171 if (PySlice_GetIndicesEx((PyObject *)idx, 1172 (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count, 1173 &start, &stop, 1174 &step, &slicelen) < 0) 1175 { 1176 return NULL; 1177 } 1178 return BufferSlice((BufferObject *)(self), start, stop); 1179 } 1180 else 1181 { 1182 PyErr_SetString(PyExc_TypeError, _("index must be int or slice")); 1183 return NULL; 1184 } 1185 } 1186 1187 static Py_ssize_t 1188 BufferAsSubscript(PyObject *self, PyObject* idx, PyObject* val) 1189 { 1190 if (PyLong_Check(idx)) 1191 { 1192 long n = PyLong_AsLong(idx); 1193 return RBAsItem((BufferObject *)(self), n, val, 1, 1194 (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count, 1195 NULL); 1196 } else if (PySlice_Check(idx)) 1197 { 1198 Py_ssize_t start, stop, step, slicelen; 1199 1200 if (CheckBuffer((BufferObject *) self)) 1201 return -1; 1202 1203 if (PySlice_GetIndicesEx((PyObject *)idx, 1204 (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count, 1205 &start, &stop, 1206 &step, &slicelen) < 0) 1207 { 1208 return -1; 1209 } 1210 return RBAsSlice((BufferObject *)(self), start, stop, val, 1, 1211 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count, 1212 NULL); 1213 } 1214 else 1215 { 1216 PyErr_SetString(PyExc_TypeError, _("index must be int or slice")); 1217 return -1; 1218 } 1219 } 1220 1221 static PySequenceMethods RangeAsSeq = { 1222 (lenfunc) RangeLength, /* sq_length, len(x) */ 1223 (binaryfunc) 0, /* RangeConcat, sq_concat, x+y */ 1224 (ssizeargfunc) 0, /* RangeRepeat, sq_repeat, x*n */ 1225 (ssizeargfunc) RangeItem, /* sq_item, x[i] */ 1226 0, /* was_sq_slice, x[i:j] */ 1227 (ssizeobjargproc) RangeAsItem, /* sq_as_item, x[i]=v */ 1228 0, /* sq_ass_slice, x[i:j]=v */ 1229 0, /* sq_contains */ 1230 0, /* sq_inplace_concat */ 1231 0, /* sq_inplace_repeat */ 1232 }; 1233 1234 static PyMappingMethods RangeAsMapping = { 1235 /* mp_length */ (lenfunc)RangeLength, 1236 /* mp_subscript */ (binaryfunc)RangeSubscript, 1237 /* mp_ass_subscript */ (objobjargproc)RangeAsSubscript, 1238 }; 1239 1240 /* Line range object - Implementation 1241 */ 1242 1243 static PyObject * 1244 RangeGetattro(PyObject *self, PyObject *nameobj) 1245 { 1246 GET_ATTR_STRING(name, nameobj); 1247 1248 if (strcmp(name, "start") == 0) 1249 return Py_BuildValue("n", ((RangeObject *)(self))->start - 1); 1250 else if (strcmp(name, "end") == 0) 1251 return Py_BuildValue("n", ((RangeObject *)(self))->end - 1); 1252 else 1253 return PyObject_GenericGetAttr(self, nameobj); 1254 } 1255 1256 /****************/ 1257 1258 static Py_ssize_t 1259 RangeAsItem(PyObject *self, Py_ssize_t n, PyObject *val) 1260 { 1261 return RBAsItem(((RangeObject *)(self))->buf, n, val, 1262 ((RangeObject *)(self))->start, 1263 ((RangeObject *)(self))->end, 1264 &((RangeObject *)(self))->end); 1265 } 1266 1267 static Py_ssize_t 1268 RangeAsSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi, PyObject *val) 1269 { 1270 return RBAsSlice(((RangeObject *)(self))->buf, lo, hi, val, 1271 ((RangeObject *)(self))->start, 1272 ((RangeObject *)(self))->end, 1273 &((RangeObject *)(self))->end); 1274 } 1275 1276 static PyObject * 1277 RangeSubscript(PyObject *self, PyObject* idx) 1278 { 1279 if (PyLong_Check(idx)) 1280 { 1281 long _idx = PyLong_AsLong(idx); 1282 return RangeItem((RangeObject *)(self), _idx); 1283 } else if (PySlice_Check(idx)) 1284 { 1285 Py_ssize_t start, stop, step, slicelen; 1286 1287 if (PySlice_GetIndicesEx((PyObject *)idx, 1288 ((RangeObject *)(self))->end-((RangeObject *)(self))->start+1, 1289 &start, &stop, 1290 &step, &slicelen) < 0) 1291 { 1292 return NULL; 1293 } 1294 return RangeSlice((RangeObject *)(self), start, stop); 1295 } 1296 else 1297 { 1298 PyErr_SetString(PyExc_TypeError, _("index must be int or slice")); 1299 return NULL; 1300 } 1301 } 1302 1303 static Py_ssize_t 1304 RangeAsSubscript(PyObject *self, PyObject *idx, PyObject *val) 1305 { 1306 if (PyLong_Check(idx)) 1307 { 1308 long n = PyLong_AsLong(idx); 1309 return RangeAsItem(self, n, val); 1310 } else if (PySlice_Check(idx)) 1311 { 1312 Py_ssize_t start, stop, step, slicelen; 1313 1314 if (PySlice_GetIndicesEx((PyObject *)idx, 1315 ((RangeObject *)(self))->end-((RangeObject *)(self))->start+1, 1316 &start, &stop, 1317 &step, &slicelen) < 0) 1318 { 1319 return -1; 1320 } 1321 return RangeAsSlice(self, start, stop, val); 1322 } 1323 else 1324 { 1325 PyErr_SetString(PyExc_TypeError, _("index must be int or slice")); 1326 return -1; 1327 } 1328 } 1329 1330 /* TabPage object - Implementation 1331 */ 1332 1333 static PyObject * 1334 TabPageGetattro(PyObject *self, PyObject *nameobj) 1335 { 1336 PyObject *r; 1337 1338 GET_ATTR_STRING(name, nameobj); 1339 1340 if ((r = TabPageAttrValid((TabPageObject *)(self), name))) 1341 return r; 1342 1343 if (CheckTabPage((TabPageObject *)(self))) 1344 return NULL; 1345 1346 r = TabPageAttr((TabPageObject *)(self), name); 1347 if (r || PyErr_Occurred()) 1348 return r; 1349 else 1350 return PyObject_GenericGetAttr(self, nameobj); 1351 } 1352 1353 /* Window object - Implementation 1354 */ 1355 1356 static PyObject * 1357 WindowGetattro(PyObject *self, PyObject *nameobj) 1358 { 1359 PyObject *r; 1360 1361 GET_ATTR_STRING(name, nameobj); 1362 1363 if ((r = WindowAttrValid((WindowObject *)(self), name))) 1364 return r; 1365 1366 if (CheckWindow((WindowObject *)(self))) 1367 return NULL; 1368 1369 r = WindowAttr((WindowObject *)(self), name); 1370 if (r || PyErr_Occurred()) 1371 return r; 1372 else 1373 return PyObject_GenericGetAttr(self, nameobj); 1374 } 1375 1376 static int 1377 WindowSetattro(PyObject *self, PyObject *nameobj, PyObject *val) 1378 { 1379 GET_ATTR_STRING(name, nameobj); 1380 1381 return WindowSetattr((WindowObject *)(self), name, val); 1382 } 1383 1384 /* Tab page list object - Definitions 1385 */ 1386 1387 static PySequenceMethods TabListAsSeq = { 1388 (lenfunc) TabListLength, /* sq_length, len(x) */ 1389 (binaryfunc) 0, /* sq_concat, x+y */ 1390 (ssizeargfunc) 0, /* sq_repeat, x*n */ 1391 (ssizeargfunc) TabListItem, /* sq_item, x[i] */ 1392 0, /* sq_slice, x[i:j] */ 1393 (ssizeobjargproc)0, /* sq_as_item, x[i]=v */ 1394 0, /* sq_ass_slice, x[i:j]=v */ 1395 0, /* sq_contains */ 1396 0, /* sq_inplace_concat */ 1397 0, /* sq_inplace_repeat */ 1398 }; 1399 1400 /* Window list object - Definitions 1401 */ 1402 1403 static PySequenceMethods WinListAsSeq = { 1404 (lenfunc) WinListLength, /* sq_length, len(x) */ 1405 (binaryfunc) 0, /* sq_concat, x+y */ 1406 (ssizeargfunc) 0, /* sq_repeat, x*n */ 1407 (ssizeargfunc) WinListItem, /* sq_item, x[i] */ 1408 0, /* sq_slice, x[i:j] */ 1409 (ssizeobjargproc)0, /* sq_as_item, x[i]=v */ 1410 0, /* sq_ass_slice, x[i:j]=v */ 1411 0, /* sq_contains */ 1412 0, /* sq_inplace_concat */ 1413 0, /* sq_inplace_repeat */ 1414 }; 1415 1416 /* Current items object - Implementation 1417 */ 1418 static PyObject * 1419 CurrentGetattro(PyObject *self, PyObject *nameobj) 1420 { 1421 PyObject *r; 1422 GET_ATTR_STRING(name, nameobj); 1423 if (!(r = CurrentGetattr(self, name))) 1424 return PyObject_GenericGetAttr(self, nameobj); 1425 return r; 1426 } 1427 1428 static int 1429 CurrentSetattro(PyObject *self, PyObject *nameobj, PyObject *value) 1430 { 1431 GET_ATTR_STRING(name, nameobj); 1432 return CurrentSetattr(self, name, value); 1433 } 1434 1435 /* Dictionary object - Definitions 1436 */ 1437 1438 static PyObject * 1439 DictionaryGetattro(PyObject *self, PyObject *nameobj) 1440 { 1441 DictionaryObject *this = ((DictionaryObject *) (self)); 1442 1443 GET_ATTR_STRING(name, nameobj); 1444 1445 if (strcmp(name, "locked") == 0) 1446 return PyLong_FromLong(this->dict->dv_lock); 1447 else if (strcmp(name, "scope") == 0) 1448 return PyLong_FromLong(this->dict->dv_scope); 1449 1450 return PyObject_GenericGetAttr(self, nameobj); 1451 } 1452 1453 static int 1454 DictionarySetattro(PyObject *self, PyObject *nameobj, PyObject *val) 1455 { 1456 GET_ATTR_STRING(name, nameobj); 1457 return DictionarySetattr((DictionaryObject *)(self), name, val); 1458 } 1459 1460 /* List object - Definitions 1461 */ 1462 1463 static PySequenceMethods ListAsSeq = { 1464 (lenfunc) ListLength, /* sq_length, len(x) */ 1465 (binaryfunc) 0, /* RangeConcat, sq_concat, x+y */ 1466 (ssizeargfunc) 0, /* RangeRepeat, sq_repeat, x*n */ 1467 (ssizeargfunc) ListItem, /* sq_item, x[i] */ 1468 (void *) 0, /* was_sq_slice, x[i:j] */ 1469 (ssizeobjargproc) ListAssItem, /* sq_as_item, x[i]=v */ 1470 (void *) 0, /* was_sq_ass_slice, x[i:j]=v */ 1471 0, /* sq_contains */ 1472 (binaryfunc) ListConcatInPlace,/* sq_inplace_concat */ 1473 0, /* sq_inplace_repeat */ 1474 }; 1475 1476 static PyObject *ListSubscript(PyObject *, PyObject *); 1477 static Py_ssize_t ListAsSubscript(PyObject *, PyObject *, PyObject *); 1478 1479 static PyMappingMethods ListAsMapping = { 1480 /* mp_length */ (lenfunc) ListLength, 1481 /* mp_subscript */ (binaryfunc) ListSubscript, 1482 /* mp_ass_subscript */ (objobjargproc) ListAsSubscript, 1483 }; 1484 1485 static PyObject * 1486 ListSubscript(PyObject *self, PyObject* idx) 1487 { 1488 if (PyLong_Check(idx)) 1489 { 1490 long _idx = PyLong_AsLong(idx); 1491 return ListItem((ListObject *)(self), _idx); 1492 } 1493 else if (PySlice_Check(idx)) 1494 { 1495 Py_ssize_t start, stop, step, slicelen; 1496 1497 if (PySlice_GetIndicesEx(idx, ListLength((ListObject *)(self)), 1498 &start, &stop, &step, &slicelen) < 0) 1499 return NULL; 1500 return ListSlice((ListObject *)(self), start, stop); 1501 } 1502 else 1503 { 1504 PyErr_SetString(PyExc_TypeError, _("index must be int or slice")); 1505 return NULL; 1506 } 1507 } 1508 1509 static Py_ssize_t 1510 ListAsSubscript(PyObject *self, PyObject *idx, PyObject *obj) 1511 { 1512 if (PyLong_Check(idx)) 1513 { 1514 long _idx = PyLong_AsLong(idx); 1515 return ListAssItem((ListObject *)(self), _idx, obj); 1516 } 1517 else if (PySlice_Check(idx)) 1518 { 1519 Py_ssize_t start, stop, step, slicelen; 1520 1521 if (PySlice_GetIndicesEx(idx, ListLength((ListObject *)(self)), 1522 &start, &stop, &step, &slicelen) < 0) 1523 return -1; 1524 return ListAssSlice((ListObject *)(self), start, stop, obj); 1525 } 1526 else 1527 { 1528 PyErr_SetString(PyExc_TypeError, _("index must be int or slice")); 1529 return -1; 1530 } 1531 } 1532 1533 static PyObject * 1534 ListGetattro(PyObject *self, PyObject *nameobj) 1535 { 1536 GET_ATTR_STRING(name, nameobj); 1537 1538 if (strcmp(name, "locked") == 0) 1539 return PyLong_FromLong(((ListObject *) (self))->list->lv_lock); 1540 1541 return PyObject_GenericGetAttr(self, nameobj); 1542 } 1543 1544 static int 1545 ListSetattro(PyObject *self, PyObject *nameobj, PyObject *val) 1546 { 1547 GET_ATTR_STRING(name, nameobj); 1548 return ListSetattr((ListObject *)(self), name, val); 1549 } 1550 1551 /* Function object - Definitions 1552 */ 1553 1554 static PyObject * 1555 FunctionGetattro(PyObject *self, PyObject *nameobj) 1556 { 1557 FunctionObject *this = (FunctionObject *)(self); 1558 1559 GET_ATTR_STRING(name, nameobj); 1560 1561 if (strcmp(name, "name") == 0) 1562 return PyUnicode_FromString((char *)(this->name)); 1563 1564 return PyObject_GenericGetAttr(self, nameobj); 1565 } 1566 1567 /* External interface 1568 */ 1569 1570 void 1571 python3_buffer_free(buf_T *buf) 1572 { 1573 if (BUF_PYTHON_REF(buf) != NULL) 1574 { 1575 BufferObject *bp = BUF_PYTHON_REF(buf); 1576 bp->buf = INVALID_BUFFER_VALUE; 1577 BUF_PYTHON_REF(buf) = NULL; 1578 } 1579 } 1580 1581 #if defined(FEAT_WINDOWS) || defined(PROTO) 1582 void 1583 python3_window_free(win_T *win) 1584 { 1585 if (WIN_PYTHON_REF(win) != NULL) 1586 { 1587 WindowObject *wp = WIN_PYTHON_REF(win); 1588 wp->win = INVALID_WINDOW_VALUE; 1589 WIN_PYTHON_REF(win) = NULL; 1590 } 1591 } 1592 1593 void 1594 python3_tabpage_free(tabpage_T *tab) 1595 { 1596 if (TAB_PYTHON_REF(tab) != NULL) 1597 { 1598 TabPageObject *tp = TAB_PYTHON_REF(tab); 1599 tp->tab = INVALID_TABPAGE_VALUE; 1600 TAB_PYTHON_REF(tab) = NULL; 1601 } 1602 } 1603 #endif 1604 1605 static PyObject * 1606 Py3Init_vim(void) 1607 { 1608 /* The special value is removed from sys.path in Python3_Init(). */ 1609 static wchar_t *(argv[2]) = {L"/must>not&exist/foo", NULL}; 1610 1611 if (init_types()) 1612 return NULL; 1613 1614 /* Set sys.argv[] to avoid a crash in warn(). */ 1615 PySys_SetArgv(1, argv); 1616 1617 if ((vim_module = PyModule_Create(&vimmodule)) == NULL) 1618 return NULL; 1619 1620 if (populate_module(vim_module, PyModule_AddObject, PyObject_GetAttrString)) 1621 return NULL; 1622 1623 if (init_sys_path()) 1624 return NULL; 1625 1626 return vim_module; 1627 } 1628 1629 /************************************************************************* 1630 * 4. Utility functions for handling the interface between Vim and Python. 1631 */ 1632 1633 /* Convert a Vim line into a Python string. 1634 * All internal newlines are replaced by null characters. 1635 * 1636 * On errors, the Python exception data is set, and NULL is returned. 1637 */ 1638 static PyObject * 1639 LineToString(const char *str) 1640 { 1641 PyObject *result; 1642 Py_ssize_t len = strlen(str); 1643 char *tmp,*p; 1644 1645 tmp = (char *)alloc((unsigned)(len+1)); 1646 p = tmp; 1647 if (p == NULL) 1648 { 1649 PyErr_NoMemory(); 1650 return NULL; 1651 } 1652 1653 while (*str) 1654 { 1655 if (*str == '\n') 1656 *p = '\0'; 1657 else 1658 *p = *str; 1659 1660 ++p; 1661 ++str; 1662 } 1663 *p = '\0'; 1664 1665 result = PyUnicode_Decode(tmp, len, (char *)ENC_OPT, CODEC_ERROR_HANDLER); 1666 1667 vim_free(tmp); 1668 return result; 1669 } 1670 1671 void 1672 do_py3eval (char_u *str, typval_T *rettv) 1673 { 1674 DoPyCommand((char *) str, 1675 (rangeinitializer) init_range_eval, 1676 (runner) run_eval, 1677 (void *) rettv); 1678 switch(rettv->v_type) 1679 { 1680 case VAR_DICT: ++rettv->vval.v_dict->dv_refcount; break; 1681 case VAR_LIST: ++rettv->vval.v_list->lv_refcount; break; 1682 case VAR_FUNC: func_ref(rettv->vval.v_string); break; 1683 case VAR_UNKNOWN: 1684 rettv->v_type = VAR_NUMBER; 1685 rettv->vval.v_number = 0; 1686 break; 1687 } 1688 } 1689 1690 void 1691 set_ref_in_python3 (int copyID) 1692 { 1693 set_ref_in_py(copyID); 1694 } 1695