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