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