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