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