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