xref: /vim-8.2.3635/src/if_python3.c (revision 83cd0156) 
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
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
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
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
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 *
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
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
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
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
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 *
918 call_PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
919 {
920     return PyType_GenericNew(type,args,kwds);
921 }
922 
923     static PyObject *
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
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
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
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
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
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
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
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
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
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 *
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
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 *
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
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 *
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
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 *
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
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
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 *
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
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 *
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 *
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
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 *
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
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 *
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
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 *
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
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 *
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
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
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
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 *
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 *
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
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
1865 set_ref_in_python3(int copyID)
1866 {
1867     return set_ref_in_py(copyID);
1868 }
1869