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