xref: /vim-8.2.3635/src/if_python3.c (revision abcbb0e9) 
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 /*
675  * Load library and get all pointers.
676  * Parameter 'libname' provides name of DLL.
677  * Return OK or FAIL.
678  */
679     static int
680 py3_runtime_link_init(char *libname, int verbose)
681 {
682     int i;
683     PYTHON_PROC *ucs_from_string = (PYTHON_PROC *)&py3_PyUnicode_FromString;
684     PYTHON_PROC *ucs_decode = (PYTHON_PROC *)&py3_PyUnicode_Decode;
685     PYTHON_PROC *ucs_as_encoded_string =
686 				 (PYTHON_PROC *)&py3_PyUnicode_AsEncodedString;
687 
688 # if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON)
689     // Can't have Python and Python3 loaded at the same time.
690     // It cause a crash, because RTLD_GLOBAL is needed for
691     // standard C extension libraries of one or both python versions.
692     if (python_loaded())
693     {
694 	if (verbose)
695 	    emsg(_("E837: This Vim cannot execute :py3 after using :python"));
696 	return FAIL;
697     }
698 # endif
699 
700     if (hinstPy3 != 0)
701 	return OK;
702     hinstPy3 = load_dll(libname);
703 
704     if (!hinstPy3)
705     {
706 	if (verbose)
707 	    semsg(_(e_loadlib), libname);
708 	return FAIL;
709     }
710 
711     for (i = 0; py3_funcname_table[i].ptr; ++i)
712     {
713 	if ((*py3_funcname_table[i].ptr = symbol_from_dll(hinstPy3,
714 			py3_funcname_table[i].name)) == NULL)
715 	{
716 	    close_dll(hinstPy3);
717 	    hinstPy3 = 0;
718 	    if (verbose)
719 		semsg(_(e_loadfunc), py3_funcname_table[i].name);
720 	    return FAIL;
721 	}
722     }
723 
724     // Load unicode functions separately as only the ucs2 or the ucs4 functions
725     // will be present in the library.
726 # if PY_VERSION_HEX >= 0x030300f0
727     *ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicode_FromString");
728     *ucs_decode = symbol_from_dll(hinstPy3, "PyUnicode_Decode");
729     *ucs_as_encoded_string = symbol_from_dll(hinstPy3,
730 	    "PyUnicode_AsEncodedString");
731 # else
732     *ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicodeUCS2_FromString");
733     *ucs_decode = symbol_from_dll(hinstPy3,
734 	    "PyUnicodeUCS2_Decode");
735     *ucs_as_encoded_string = symbol_from_dll(hinstPy3,
736 	    "PyUnicodeUCS2_AsEncodedString");
737     if (*ucs_from_string == NULL || *ucs_decode == NULL
738 					     || *ucs_as_encoded_string == NULL)
739     {
740 	*ucs_from_string = symbol_from_dll(hinstPy3,
741 		"PyUnicodeUCS4_FromString");
742 	*ucs_decode = symbol_from_dll(hinstPy3,
743 		"PyUnicodeUCS4_Decode");
744 	*ucs_as_encoded_string = symbol_from_dll(hinstPy3,
745 		"PyUnicodeUCS4_AsEncodedString");
746     }
747 # endif
748     if (*ucs_from_string == NULL || *ucs_decode == NULL
749 					     || *ucs_as_encoded_string == NULL)
750     {
751 	close_dll(hinstPy3);
752 	hinstPy3 = 0;
753 	if (verbose)
754 	    semsg(_(e_loadfunc), "PyUnicode_UCSX_*");
755 	return FAIL;
756     }
757 
758     return OK;
759 }
760 
761 /*
762  * If python is enabled (there is installed python on Windows system) return
763  * TRUE, else FALSE.
764  */
765     int
766 python3_enabled(int verbose)
767 {
768     return py3_runtime_link_init((char *)p_py3dll, verbose) == OK;
769 }
770 
771 /*
772  * Load the standard Python exceptions - don't import the symbols from the
773  * DLL, as this can cause errors (importing data symbols is not reliable).
774  */
775     static void
776 get_py3_exceptions(void)
777 {
778     PyObject *exmod = PyImport_ImportModule("builtins");
779     PyObject *exdict = PyModule_GetDict(exmod);
780     p3imp_PyExc_AttributeError = PyDict_GetItemString(exdict, "AttributeError");
781     p3imp_PyExc_IndexError = PyDict_GetItemString(exdict, "IndexError");
782     p3imp_PyExc_KeyError = PyDict_GetItemString(exdict, "KeyError");
783     p3imp_PyExc_KeyboardInterrupt = PyDict_GetItemString(exdict, "KeyboardInterrupt");
784     p3imp_PyExc_TypeError = PyDict_GetItemString(exdict, "TypeError");
785     p3imp_PyExc_ValueError = PyDict_GetItemString(exdict, "ValueError");
786     p3imp_PyExc_SystemExit = PyDict_GetItemString(exdict, "SystemExit");
787     p3imp_PyExc_RuntimeError = PyDict_GetItemString(exdict, "RuntimeError");
788     p3imp_PyExc_ImportError = PyDict_GetItemString(exdict, "ImportError");
789     p3imp_PyExc_OverflowError = PyDict_GetItemString(exdict, "OverflowError");
790     Py_XINCREF(p3imp_PyExc_AttributeError);
791     Py_XINCREF(p3imp_PyExc_IndexError);
792     Py_XINCREF(p3imp_PyExc_KeyError);
793     Py_XINCREF(p3imp_PyExc_KeyboardInterrupt);
794     Py_XINCREF(p3imp_PyExc_TypeError);
795     Py_XINCREF(p3imp_PyExc_ValueError);
796     Py_XINCREF(p3imp_PyExc_SystemExit);
797     Py_XINCREF(p3imp_PyExc_RuntimeError);
798     Py_XINCREF(p3imp_PyExc_ImportError);
799     Py_XINCREF(p3imp_PyExc_OverflowError);
800     Py_XDECREF(exmod);
801 }
802 #endif // DYNAMIC_PYTHON3
803 
804 static int py3initialised = 0;
805 #define PYINITIALISED py3initialised
806 static int python_end_called = FALSE;
807 
808 #define DESTRUCTOR_FINISH(self) Py_TYPE(self)->tp_free((PyObject*)self)
809 
810 #define WIN_PYTHON_REF(win) win->w_python3_ref
811 #define BUF_PYTHON_REF(buf) buf->b_python3_ref
812 #define TAB_PYTHON_REF(tab) tab->tp_python3_ref
813 
814     static void
815 call_PyObject_Free(void *p)
816 {
817 #if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC)
818     _PyObject_DebugFree(p);
819 #else
820     PyObject_Free(p);
821 #endif
822 }
823 
824     static PyObject *
825 call_PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
826 {
827     return PyType_GenericNew(type,args,kwds);
828 }
829 
830     static PyObject *
831 call_PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
832 {
833     return PyType_GenericAlloc(type,nitems);
834 }
835 
836 static PyObject *OutputGetattro(PyObject *, PyObject *);
837 static int OutputSetattro(PyObject *, PyObject *, PyObject *);
838 static PyObject *BufferGetattro(PyObject *, PyObject *);
839 static int BufferSetattro(PyObject *, PyObject *, PyObject *);
840 static PyObject *TabPageGetattro(PyObject *, PyObject *);
841 static PyObject *WindowGetattro(PyObject *, PyObject *);
842 static int WindowSetattro(PyObject *, PyObject *, PyObject *);
843 static PyObject *RangeGetattro(PyObject *, PyObject *);
844 static PyObject *CurrentGetattro(PyObject *, PyObject *);
845 static int CurrentSetattro(PyObject *, PyObject *, PyObject *);
846 static PyObject *DictionaryGetattro(PyObject *, PyObject *);
847 static int DictionarySetattro(PyObject *, PyObject *, PyObject *);
848 static PyObject *ListGetattro(PyObject *, PyObject *);
849 static int ListSetattro(PyObject *, PyObject *, PyObject *);
850 static PyObject *FunctionGetattro(PyObject *, PyObject *);
851 
852 static struct PyModuleDef vimmodule;
853 
854 #define PY_CAN_RECURSE
855 
856 /*
857  * Include the code shared with if_python.c
858  */
859 #include "if_py_both.h"
860 
861 // NOTE: Must always be used at the start of a block, since it declares "name".
862 #define GET_ATTR_STRING(name, nameobj) \
863     char	*name = ""; \
864     if (PyUnicode_Check(nameobj)) \
865 	name = (char *)_PyUnicode_AsString(nameobj)
866 
867 #define PY3OBJ_DELETED(obj) (obj->ob_base.ob_refcnt<=0)
868 
869 ///////////////////////////////////////////////////////
870 // Internal function prototypes.
871 
872 static PyObject *Py3Init_vim(void);
873 
874 ///////////////////////////////////////////////////////
875 // 1. Python interpreter main program.
876 
877     void
878 python3_end(void)
879 {
880     static int recurse = 0;
881 
882     // If a crash occurs while doing this, don't try again.
883     if (recurse != 0)
884 	return;
885 
886     python_end_called = TRUE;
887     ++recurse;
888 
889 #ifdef DYNAMIC_PYTHON3
890     if (hinstPy3)
891 #endif
892     if (Py_IsInitialized())
893     {
894 	// acquire lock before finalizing
895 	PyGILState_Ensure();
896 
897 	Py_Finalize();
898     }
899 
900     --recurse;
901 }
902 
903 #if (defined(DYNAMIC_PYTHON3) && defined(DYNAMIC_PYTHON) && defined(FEAT_PYTHON) && defined(UNIX)) || defined(PROTO)
904     int
905 python3_loaded(void)
906 {
907     return (hinstPy3 != 0);
908 }
909 #endif
910 
911 static wchar_t *py_home_buf = NULL;
912 
913 #if defined(MSWIN) && (PY_VERSION_HEX >= 0x030500f0)
914 /*
915  * Return TRUE if stdin is readable from Python 3.
916  */
917     static BOOL
918 is_stdin_readable(void)
919 {
920     DWORD	    mode, eventnum;
921     struct _stat    st;
922     int		    fd = fileno(stdin);
923     HANDLE	    hstdin = (HANDLE)_get_osfhandle(fd);
924 
925     // Check if stdin is connected to the console.
926     if (GetConsoleMode(hstdin, &mode))
927 	// Check if it is opened as input.
928 	return GetNumberOfConsoleInputEvents(hstdin, &eventnum);
929 
930     return _fstat(fd, &st) == 0;
931 }
932 
933 // Python 3.5 or later will abort inside Py_Initialize() when stdin has
934 // been closed (i.e. executed by "vim -").  Reconnect stdin to CONIN$.
935 // Note that the python DLL is linked to its own stdio DLL which can be
936 // differ from Vim's stdio.
937     static void
938 reset_stdin(void)
939 {
940     FILE *(*py__acrt_iob_func)(unsigned) = NULL;
941     FILE *(*pyfreopen)(const char *, const char *, FILE *) = NULL;
942     HINSTANCE hinst;
943 
944 # ifdef DYNAMIC_PYTHON3
945     hinst = hinstPy3;
946 # else
947     hinst = GetModuleHandle(PYTHON3_DLL);
948 # endif
949     if (hinst == NULL || is_stdin_readable())
950 	return;
951 
952     // Get "freopen" and "stdin" which are used in the python DLL.
953     // "stdin" is defined as "__acrt_iob_func(0)" in VC++ 2015 or later.
954     py__acrt_iob_func = get_dll_import_func(hinst, "__acrt_iob_func");
955     if (py__acrt_iob_func)
956     {
957 	HINSTANCE hpystdiodll = find_imported_module_by_funcname(hinst,
958 							    "__acrt_iob_func");
959 	if (hpystdiodll)
960 	    pyfreopen = (void *)GetProcAddress(hpystdiodll, "freopen");
961     }
962 
963     // Reconnect stdin to CONIN$.
964     if (pyfreopen != NULL)
965 	pyfreopen("CONIN$", "r", py__acrt_iob_func(0));
966     else
967 	freopen("CONIN$", "r", stdin);
968 }
969 #else
970 # define reset_stdin()
971 #endif
972 
973     static int
974 Python3_Init(void)
975 {
976     if (!py3initialised)
977     {
978 #ifdef DYNAMIC_PYTHON3
979 	if (!python3_enabled(TRUE))
980 	{
981 	    emsg(_("E263: Sorry, this command is disabled, the Python library could not be loaded."));
982 	    goto fail;
983 	}
984 #endif
985 
986 	init_structs();
987 
988 	if (*p_py3home != NUL)
989 	{
990 	    size_t len = mbstowcs(NULL, (char *)p_py3home, 0) + 1;
991 
992 	    // The string must not change later, make a copy in static memory.
993 	    py_home_buf = ALLOC_MULT(wchar_t, len);
994 	    if (py_home_buf != NULL && mbstowcs(
995 			    py_home_buf, (char *)p_py3home, len) != (size_t)-1)
996 		Py_SetPythonHome(py_home_buf);
997 	}
998 #ifdef PYTHON3_HOME
999 	else if (mch_getenv((char_u *)"PYTHONHOME") == NULL)
1000 	    Py_SetPythonHome(PYTHON3_HOME);
1001 #endif
1002 
1003 	PyImport_AppendInittab("vim", Py3Init_vim);
1004 
1005 	reset_stdin();
1006 	Py_Initialize();
1007 
1008 #if PY_VERSION_HEX < 0x03090000
1009 	// Initialise threads.  This is deprecated since Python 3.9.
1010 	PyEval_InitThreads();
1011 #endif
1012 #ifdef DYNAMIC_PYTHON3
1013 	get_py3_exceptions();
1014 #endif
1015 
1016 	if (PythonIO_Init_io())
1017 	    goto fail;
1018 
1019 	globals = PyModule_GetDict(PyImport_AddModule("__main__"));
1020 
1021 	// Remove the element from sys.path that was added because of our
1022 	// argv[0] value in Py3Init_vim().  Previously we used an empty
1023 	// string, but depending on the OS we then get an empty entry or
1024 	// the current directory in sys.path.
1025 	// Only after vim has been imported, the element does exist in
1026 	// sys.path.
1027 	PyRun_SimpleString("import vim; import sys; sys.path = list(filter(lambda x: not x.endswith('must>not&exist'), sys.path))");
1028 
1029 	// Without the call to PyEval_SaveThread, thread specific state (such
1030 	// as the system trace hook), will be lost between invocations of
1031 	// Python code.
1032 	// GIL may have been created and acquired in PyEval_InitThreads() and
1033 	// thread state is created in Py_Initialize(); there
1034 	// _PyGILState_NoteThreadState() also sets gilcounter to 1 (python must
1035 	// have threads enabled!), so the following does both: unlock GIL and
1036 	// save thread state in TLS without deleting thread state
1037 	PyEval_SaveThread();
1038 
1039 	py3initialised = 1;
1040     }
1041 
1042     return 0;
1043 
1044 fail:
1045     // We call PythonIO_Flush() here to print any Python errors.
1046     // This is OK, as it is possible to call this function even
1047     // if PythonIO_Init_io() has not completed successfully (it will
1048     // not do anything in this case).
1049     PythonIO_Flush();
1050     return -1;
1051 }
1052 
1053 /*
1054  * External interface
1055  */
1056     static void
1057 DoPyCommand(const char *cmd, rangeinitializer init_range, runner run, void *arg)
1058 {
1059 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
1060     char		*saved_locale;
1061 #endif
1062     PyObject		*cmdstr;
1063     PyObject		*cmdbytes;
1064     PyGILState_STATE	pygilstate;
1065 
1066     if (python_end_called)
1067 	goto theend;
1068 
1069     if (Python3_Init())
1070 	goto theend;
1071 
1072     init_range(arg);
1073 
1074     Python_Release_Vim();	    // leave Vim
1075 
1076 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
1077     // Python only works properly when the LC_NUMERIC locale is "C".
1078     saved_locale = setlocale(LC_NUMERIC, NULL);
1079     if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0)
1080 	saved_locale = NULL;
1081     else
1082     {
1083 	// Need to make a copy, value may change when setting new locale.
1084 	saved_locale = (char *)vim_strsave((char_u *)saved_locale);
1085 	(void)setlocale(LC_NUMERIC, "C");
1086     }
1087 #endif
1088 
1089     pygilstate = PyGILState_Ensure();
1090 
1091     // PyRun_SimpleString expects a UTF-8 string. Wrong encoding may cause
1092     // SyntaxError (unicode error).
1093     cmdstr = PyUnicode_Decode(cmd, strlen(cmd),
1094 					(char *)ENC_OPT, ERRORS_DECODE_ARG);
1095     cmdbytes = PyUnicode_AsEncodedString(cmdstr, "utf-8", ERRORS_ENCODE_ARG);
1096     Py_XDECREF(cmdstr);
1097 
1098     run(PyBytes_AsString(cmdbytes), arg, &pygilstate);
1099     Py_XDECREF(cmdbytes);
1100 
1101     PyGILState_Release(pygilstate);
1102 
1103 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
1104     if (saved_locale != NULL)
1105     {
1106 	(void)setlocale(LC_NUMERIC, saved_locale);
1107 	vim_free(saved_locale);
1108     }
1109 #endif
1110 
1111     Python_Lock_Vim();		    // enter Vim
1112     PythonIO_Flush();
1113 
1114 theend:
1115     return;	    // keeps lint happy
1116 }
1117 
1118 /*
1119  * ":py3"
1120  */
1121     void
1122 ex_py3(exarg_T *eap)
1123 {
1124     char_u *script;
1125 
1126     script = script_get(eap, eap->arg);
1127     if (!eap->skip)
1128     {
1129 	if (p_pyx == 0)
1130 	    p_pyx = 3;
1131 
1132 	DoPyCommand(script == NULL ? (char *) eap->arg : (char *) script,
1133 		(rangeinitializer) init_range_cmd,
1134 		(runner) run_cmd,
1135 		(void *) eap);
1136     }
1137     vim_free(script);
1138 }
1139 
1140 #define BUFFER_SIZE 2048
1141 
1142 /*
1143  * ":py3file"
1144  */
1145     void
1146 ex_py3file(exarg_T *eap)
1147 {
1148     static char buffer[BUFFER_SIZE];
1149     const char *file;
1150     char *p;
1151     int i;
1152 
1153     if (p_pyx == 0)
1154 	p_pyx = 3;
1155 
1156     // Have to do it like this. PyRun_SimpleFile requires you to pass a
1157     // stdio file pointer, but Vim and the Python DLL are compiled with
1158     // different options under Windows, meaning that stdio pointers aren't
1159     // compatible between the two. Yuk.
1160     //
1161     // construct: exec(compile(open('a_filename', 'rb').read(), 'a_filename', 'exec'))
1162     //
1163     // Using bytes so that Python can detect the source encoding as it normally
1164     // does. The doc does not say "compile" accept bytes, though.
1165     //
1166     // We need to escape any backslashes or single quotes in the file name, so that
1167     // Python won't mangle the file name.
1168 
1169     strcpy(buffer, "exec(compile(open('");
1170     p = buffer + 19; // size of "exec(compile(open('"
1171 
1172     for (i=0; i<2; ++i)
1173     {
1174 	file = (char *)eap->arg;
1175 	while (*file && p < buffer + (BUFFER_SIZE - 3))
1176 	{
1177 	    if (*file == '\\' || *file == '\'')
1178 		*p++ = '\\';
1179 	    *p++ = *file++;
1180 	}
1181 	// If we didn't finish the file name, we hit a buffer overflow
1182 	if (*file != '\0')
1183 	    return;
1184 	if (i==0)
1185 	{
1186 	    strcpy(p,"','rb').read(),'");
1187 	    p += 16;
1188 	}
1189 	else
1190 	{
1191 	    strcpy(p,"','exec'))");
1192 	    p += 10;
1193 	}
1194     }
1195 
1196 
1197     // Execute the file
1198     DoPyCommand(buffer,
1199 	    (rangeinitializer) init_range_cmd,
1200 	    (runner) run_cmd,
1201 	    (void *) eap);
1202 }
1203 
1204     void
1205 ex_py3do(exarg_T *eap)
1206 {
1207     if (p_pyx == 0)
1208 	p_pyx = 3;
1209 
1210     DoPyCommand((char *)eap->arg,
1211 	    (rangeinitializer)init_range_cmd,
1212 	    (runner)run_do,
1213 	    (void *)eap);
1214 }
1215 
1216 ///////////////////////////////////////////////////////
1217 // 2. Python output stream: writes output via [e]msg().
1218 
1219 // Implementation functions
1220 
1221     static PyObject *
1222 OutputGetattro(PyObject *self, PyObject *nameobj)
1223 {
1224     GET_ATTR_STRING(name, nameobj);
1225 
1226     if (strcmp(name, "softspace") == 0)
1227 	return PyLong_FromLong(((OutputObject *)(self))->softspace);
1228     else if (strcmp(name, "errors") == 0)
1229 	return PyString_FromString("strict");
1230     else if (strcmp(name, "encoding") == 0)
1231 	return PyString_FromString(ENC_OPT);
1232 
1233     return PyObject_GenericGetAttr(self, nameobj);
1234 }
1235 
1236     static int
1237 OutputSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
1238 {
1239     GET_ATTR_STRING(name, nameobj);
1240 
1241     return OutputSetattr((OutputObject *)(self), name, val);
1242 }
1243 
1244 ///////////////////////////////////////////////////////
1245 // 3. Implementation of the Vim module for Python
1246 
1247 // Window type - Implementation functions
1248 // --------------------------------------
1249 
1250 #define WindowType_Check(obj) ((obj)->ob_base.ob_type == &WindowType)
1251 
1252 // Buffer type - Implementation functions
1253 // --------------------------------------
1254 
1255 #define BufferType_Check(obj) ((obj)->ob_base.ob_type == &BufferType)
1256 
1257 static PyObject* BufferSubscript(PyObject *self, PyObject *idx);
1258 static int BufferAsSubscript(PyObject *self, PyObject *idx, PyObject *val);
1259 
1260 // Line range type - Implementation functions
1261 // --------------------------------------
1262 
1263 #define RangeType_Check(obj) ((obj)->ob_base.ob_type == &RangeType)
1264 
1265 static PyObject* RangeSubscript(PyObject *self, PyObject *idx);
1266 static int RangeAsItem(PyObject *, Py_ssize_t, PyObject *);
1267 static int RangeAsSubscript(PyObject *self, PyObject *idx, PyObject *val);
1268 
1269 // Current objects type - Implementation functions
1270 // -----------------------------------------------
1271 
1272 static PySequenceMethods BufferAsSeq = {
1273     (lenfunc)		BufferLength,	    // sq_length,    len(x)
1274     (binaryfunc)	0,		    // sq_concat,    x+y
1275     (ssizeargfunc)	0,		    // sq_repeat,    x*n
1276     (ssizeargfunc)	BufferItem,	    // sq_item,      x[i]
1277     0,					    // was_sq_slice,	 x[i:j]
1278     0,					    // sq_ass_item,  x[i]=v
1279     0,					    // sq_ass_slice, x[i:j]=v
1280     0,					    // sq_contains
1281     0,					    // sq_inplace_concat
1282     0,					    // sq_inplace_repeat
1283 };
1284 
1285 static PyMappingMethods BufferAsMapping = {
1286     /* mp_length	*/ (lenfunc)BufferLength,
1287     /* mp_subscript     */ (binaryfunc)BufferSubscript,
1288     /* mp_ass_subscript */ (objobjargproc)BufferAsSubscript,
1289 };
1290 
1291 
1292 // Buffer object
1293 
1294     static PyObject *
1295 BufferGetattro(PyObject *self, PyObject *nameobj)
1296 {
1297     PyObject *r;
1298 
1299     GET_ATTR_STRING(name, nameobj);
1300 
1301     if ((r = BufferAttrValid((BufferObject *)(self), name)))
1302 	return r;
1303 
1304     if (CheckBuffer((BufferObject *)(self)))
1305 	return NULL;
1306 
1307     r = BufferAttr((BufferObject *)(self), name);
1308     if (r || PyErr_Occurred())
1309 	return r;
1310     else
1311 	return PyObject_GenericGetAttr(self, nameobj);
1312 }
1313 
1314     static int
1315 BufferSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
1316 {
1317     GET_ATTR_STRING(name, nameobj);
1318 
1319     return BufferSetattr((BufferObject *)(self), name, val);
1320 }
1321 
1322 //////////////////
1323 
1324     static PyObject *
1325 BufferSubscript(PyObject *self, PyObject* idx)
1326 {
1327     if (PyLong_Check(idx))
1328     {
1329 	long _idx = PyLong_AsLong(idx);
1330 	return BufferItem((BufferObject *)(self), _idx);
1331     } else if (PySlice_Check(idx))
1332     {
1333 	Py_ssize_t start, stop, step, slicelen;
1334 
1335 	if (CheckBuffer((BufferObject *) self))
1336 	    return NULL;
1337 
1338 	if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
1339 	      (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1340 	      &start, &stop,
1341 	      &step, &slicelen) < 0)
1342 	    return NULL;
1343 	return BufferSlice((BufferObject *)(self), start, stop);
1344     }
1345     else
1346     {
1347 	RAISE_INVALID_INDEX_TYPE(idx);
1348 	return NULL;
1349     }
1350 }
1351 
1352     static int
1353 BufferAsSubscript(PyObject *self, PyObject* idx, PyObject* val)
1354 {
1355     if (PyLong_Check(idx))
1356     {
1357 	long n = PyLong_AsLong(idx);
1358 
1359 	if (CheckBuffer((BufferObject *) self))
1360 	    return -1;
1361 
1362 	return RBAsItem((BufferObject *)(self), n, val, 1,
1363 		    (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1364 		    NULL);
1365     } else if (PySlice_Check(idx))
1366     {
1367 	Py_ssize_t start, stop, step, slicelen;
1368 
1369 	if (CheckBuffer((BufferObject *) self))
1370 	    return -1;
1371 
1372 	if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
1373 	      (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1374 	      &start, &stop,
1375 	      &step, &slicelen) < 0)
1376 	    return -1;
1377 	return RBAsSlice((BufferObject *)(self), start, stop, val, 1,
1378 			  (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1379 			  NULL);
1380     }
1381     else
1382     {
1383 	RAISE_INVALID_INDEX_TYPE(idx);
1384 	return -1;
1385     }
1386 }
1387 
1388 static PySequenceMethods RangeAsSeq = {
1389     (lenfunc)		RangeLength,	 // sq_length,	  len(x)
1390     (binaryfunc)	0,		 // RangeConcat, sq_concat,  x+y
1391     (ssizeargfunc)	0,		 // RangeRepeat, sq_repeat,  x*n
1392     (ssizeargfunc)	RangeItem,	 // sq_item,	  x[i]
1393     0,					 // was_sq_slice,     x[i:j]
1394     (ssizeobjargproc)	RangeAsItem,	 // sq_as_item,  x[i]=v
1395     0,					 // sq_ass_slice, x[i:j]=v
1396     0,					 // sq_contains
1397     0,					 // sq_inplace_concat
1398     0,					 // sq_inplace_repeat
1399 };
1400 
1401 static PyMappingMethods RangeAsMapping = {
1402     /* mp_length	*/ (lenfunc)RangeLength,
1403     /* mp_subscript     */ (binaryfunc)RangeSubscript,
1404     /* mp_ass_subscript */ (objobjargproc)RangeAsSubscript,
1405 };
1406 
1407 // Line range object - Implementation
1408 
1409     static PyObject *
1410 RangeGetattro(PyObject *self, PyObject *nameobj)
1411 {
1412     GET_ATTR_STRING(name, nameobj);
1413 
1414     if (strcmp(name, "start") == 0)
1415 	return Py_BuildValue("n", ((RangeObject *)(self))->start - 1);
1416     else if (strcmp(name, "end") == 0)
1417 	return Py_BuildValue("n", ((RangeObject *)(self))->end - 1);
1418     else
1419 	return PyObject_GenericGetAttr(self, nameobj);
1420 }
1421 
1422 ////////////////
1423 
1424     static int
1425 RangeAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
1426 {
1427     return RBAsItem(((RangeObject *)(self))->buf, n, val,
1428 		    ((RangeObject *)(self))->start,
1429 		    ((RangeObject *)(self))->end,
1430 		    &((RangeObject *)(self))->end);
1431 }
1432 
1433     static Py_ssize_t
1434 RangeAsSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi, PyObject *val)
1435 {
1436     return RBAsSlice(((RangeObject *)(self))->buf, lo, hi, val,
1437 		    ((RangeObject *)(self))->start,
1438 		    ((RangeObject *)(self))->end,
1439 		    &((RangeObject *)(self))->end);
1440 }
1441 
1442     static PyObject *
1443 RangeSubscript(PyObject *self, PyObject* idx)
1444 {
1445     if (PyLong_Check(idx))
1446     {
1447 	long _idx = PyLong_AsLong(idx);
1448 	return RangeItem((RangeObject *)(self), _idx);
1449     } else if (PySlice_Check(idx))
1450     {
1451 	Py_ssize_t start, stop, step, slicelen;
1452 
1453 	if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
1454 		((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
1455 		&start, &stop,
1456 		&step, &slicelen) < 0)
1457 	    return NULL;
1458 	return RangeSlice((RangeObject *)(self), start, stop);
1459     }
1460     else
1461     {
1462 	RAISE_INVALID_INDEX_TYPE(idx);
1463 	return NULL;
1464     }
1465 }
1466 
1467     static int
1468 RangeAsSubscript(PyObject *self, PyObject *idx, PyObject *val)
1469 {
1470     if (PyLong_Check(idx))
1471     {
1472 	long n = PyLong_AsLong(idx);
1473 	return RangeAsItem(self, n, val);
1474     }
1475     else if (PySlice_Check(idx))
1476     {
1477 	Py_ssize_t start, stop, step, slicelen;
1478 
1479 	if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
1480 		((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
1481 		&start, &stop,
1482 		&step, &slicelen) < 0)
1483 	    return -1;
1484 	return RangeAsSlice(self, start, stop, val);
1485     }
1486     else
1487     {
1488 	RAISE_INVALID_INDEX_TYPE(idx);
1489 	return -1;
1490     }
1491 }
1492 
1493 // TabPage object - Implementation
1494 
1495     static PyObject *
1496 TabPageGetattro(PyObject *self, PyObject *nameobj)
1497 {
1498     PyObject *r;
1499 
1500     GET_ATTR_STRING(name, nameobj);
1501 
1502     if ((r = TabPageAttrValid((TabPageObject *)(self), name)))
1503 	return r;
1504 
1505     if (CheckTabPage((TabPageObject *)(self)))
1506 	return NULL;
1507 
1508     r = TabPageAttr((TabPageObject *)(self), name);
1509     if (r || PyErr_Occurred())
1510 	return r;
1511     else
1512 	return PyObject_GenericGetAttr(self, nameobj);
1513 }
1514 
1515 // Window object - Implementation
1516 
1517     static PyObject *
1518 WindowGetattro(PyObject *self, PyObject *nameobj)
1519 {
1520     PyObject *r;
1521 
1522     GET_ATTR_STRING(name, nameobj);
1523 
1524     if ((r = WindowAttrValid((WindowObject *)(self), name)))
1525 	return r;
1526 
1527     if (CheckWindow((WindowObject *)(self)))
1528 	return NULL;
1529 
1530     r = WindowAttr((WindowObject *)(self), name);
1531     if (r || PyErr_Occurred())
1532 	return r;
1533     else
1534 	return PyObject_GenericGetAttr(self, nameobj);
1535 }
1536 
1537     static int
1538 WindowSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
1539 {
1540     GET_ATTR_STRING(name, nameobj);
1541 
1542     return WindowSetattr((WindowObject *)(self), name, val);
1543 }
1544 
1545 // Tab page list object - Definitions
1546 
1547 static PySequenceMethods TabListAsSeq = {
1548     (lenfunc)	     TabListLength,	    // sq_length,    len(x)
1549     (binaryfunc)     0,			    // sq_concat,    x+y
1550     (ssizeargfunc)   0,			    // sq_repeat,    x*n
1551     (ssizeargfunc)   TabListItem,	    // sq_item,      x[i]
1552     0,					    // sq_slice,     x[i:j]
1553     (ssizeobjargproc)0,			    // sq_as_item,  x[i]=v
1554     0,					    // sq_ass_slice, x[i:j]=v
1555     0,					    // sq_contains
1556     0,					    // sq_inplace_concat
1557     0,					    // sq_inplace_repeat
1558 };
1559 
1560 // Window list object - Definitions
1561 
1562 static PySequenceMethods WinListAsSeq = {
1563     (lenfunc)	     WinListLength,	    // sq_length,    len(x)
1564     (binaryfunc)     0,			    // sq_concat,    x+y
1565     (ssizeargfunc)   0,			    // sq_repeat,    x*n
1566     (ssizeargfunc)   WinListItem,	    // sq_item,      x[i]
1567     0,					    // sq_slice,     x[i:j]
1568     (ssizeobjargproc)0,			    // sq_as_item,  x[i]=v
1569     0,					    // sq_ass_slice, x[i:j]=v
1570     0,					    // sq_contains
1571     0,					    // sq_inplace_concat
1572     0,					    // sq_inplace_repeat
1573 };
1574 
1575 /*
1576  * Current items object - Implementation
1577  */
1578     static PyObject *
1579 CurrentGetattro(PyObject *self, PyObject *nameobj)
1580 {
1581     PyObject	*r;
1582     GET_ATTR_STRING(name, nameobj);
1583     if (!(r = CurrentGetattr(self, name)))
1584 	return PyObject_GenericGetAttr(self, nameobj);
1585     return r;
1586 }
1587 
1588     static int
1589 CurrentSetattro(PyObject *self, PyObject *nameobj, PyObject *value)
1590 {
1591     GET_ATTR_STRING(name, nameobj);
1592     return CurrentSetattr(self, name, value);
1593 }
1594 
1595 // Dictionary object - Definitions
1596 
1597     static PyObject *
1598 DictionaryGetattro(PyObject *self, PyObject *nameobj)
1599 {
1600     DictionaryObject	*this = ((DictionaryObject *) (self));
1601 
1602     GET_ATTR_STRING(name, nameobj);
1603 
1604     if (strcmp(name, "locked") == 0)
1605 	return PyLong_FromLong(this->dict->dv_lock);
1606     else if (strcmp(name, "scope") == 0)
1607 	return PyLong_FromLong(this->dict->dv_scope);
1608 
1609     return PyObject_GenericGetAttr(self, nameobj);
1610 }
1611 
1612     static int
1613 DictionarySetattro(PyObject *self, PyObject *nameobj, PyObject *val)
1614 {
1615     GET_ATTR_STRING(name, nameobj);
1616     return DictionarySetattr((DictionaryObject *)(self), name, val);
1617 }
1618 
1619 // List object - Definitions
1620 
1621     static PyObject *
1622 ListGetattro(PyObject *self, PyObject *nameobj)
1623 {
1624     GET_ATTR_STRING(name, nameobj);
1625 
1626     if (strcmp(name, "locked") == 0)
1627 	return PyLong_FromLong(((ListObject *) (self))->list->lv_lock);
1628 
1629     return PyObject_GenericGetAttr(self, nameobj);
1630 }
1631 
1632     static int
1633 ListSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
1634 {
1635     GET_ATTR_STRING(name, nameobj);
1636     return ListSetattr((ListObject *)(self), name, val);
1637 }
1638 
1639 // Function object - Definitions
1640 
1641     static PyObject *
1642 FunctionGetattro(PyObject *self, PyObject *nameobj)
1643 {
1644     PyObject		*r;
1645     FunctionObject	*this = (FunctionObject *)(self);
1646 
1647     GET_ATTR_STRING(name, nameobj);
1648 
1649     r = FunctionAttr(this, name);
1650     if (r || PyErr_Occurred())
1651 	return r;
1652     else
1653 	return PyObject_GenericGetAttr(self, nameobj);
1654 }
1655 
1656 // External interface
1657 
1658     void
1659 python3_buffer_free(buf_T *buf)
1660 {
1661     if (BUF_PYTHON_REF(buf) != NULL)
1662     {
1663 	BufferObject *bp = BUF_PYTHON_REF(buf);
1664 	bp->buf = INVALID_BUFFER_VALUE;
1665 	BUF_PYTHON_REF(buf) = NULL;
1666     }
1667 }
1668 
1669     void
1670 python3_window_free(win_T *win)
1671 {
1672     if (WIN_PYTHON_REF(win) != NULL)
1673     {
1674 	WindowObject *wp = WIN_PYTHON_REF(win);
1675 	wp->win = INVALID_WINDOW_VALUE;
1676 	WIN_PYTHON_REF(win) = NULL;
1677     }
1678 }
1679 
1680     void
1681 python3_tabpage_free(tabpage_T *tab)
1682 {
1683     if (TAB_PYTHON_REF(tab) != NULL)
1684     {
1685 	TabPageObject *tp = TAB_PYTHON_REF(tab);
1686 	tp->tab = INVALID_TABPAGE_VALUE;
1687 	TAB_PYTHON_REF(tab) = NULL;
1688     }
1689 }
1690 
1691     static PyObject *
1692 Py3Init_vim(void)
1693 {
1694     // The special value is removed from sys.path in Python3_Init().
1695     static wchar_t *(argv[2]) = {L"/must>not&exist/foo", NULL};
1696 
1697     if (init_types())
1698 	return NULL;
1699 
1700     // Set sys.argv[] to avoid a crash in warn().
1701     PySys_SetArgv(1, argv);
1702 
1703     if ((vim_module = PyModule_Create(&vimmodule)) == NULL)
1704 	return NULL;
1705 
1706     if (populate_module(vim_module))
1707 	return NULL;
1708 
1709     if (init_sys_path())
1710 	return NULL;
1711 
1712     return vim_module;
1713 }
1714 
1715 //////////////////////////////////////////////////////////////////////////
1716 // 4. Utility functions for handling the interface between Vim and Python.
1717 
1718 /*
1719  * Convert a Vim line into a Python string.
1720  * All internal newlines are replaced by null characters.
1721  *
1722  * On errors, the Python exception data is set, and NULL is returned.
1723  */
1724     static PyObject *
1725 LineToString(const char *str)
1726 {
1727     PyObject *result;
1728     Py_ssize_t len = strlen(str);
1729     char *tmp, *p;
1730 
1731     tmp = alloc(len + 1);
1732     p = tmp;
1733     if (p == NULL)
1734     {
1735 	PyErr_NoMemory();
1736 	return NULL;
1737     }
1738 
1739     while (*str)
1740     {
1741 	if (*str == '\n')
1742 	    *p = '\0';
1743 	else
1744 	    *p = *str;
1745 
1746 	++p;
1747 	++str;
1748     }
1749     *p = '\0';
1750 
1751     result = PyUnicode_Decode(tmp, len, (char *)ENC_OPT, ERRORS_DECODE_ARG);
1752 
1753     vim_free(tmp);
1754     return result;
1755 }
1756 
1757     void
1758 do_py3eval(char_u *str, typval_T *rettv)
1759 {
1760     DoPyCommand((char *) str,
1761 	    (rangeinitializer) init_range_eval,
1762 	    (runner) run_eval,
1763 	    (void *) rettv);
1764     if (rettv->v_type == VAR_UNKNOWN)
1765     {
1766 	rettv->v_type = VAR_NUMBER;
1767 	rettv->vval.v_number = 0;
1768     }
1769 }
1770 
1771     int
1772 set_ref_in_python3(int copyID)
1773 {
1774     return set_ref_in_py(copyID);
1775 }
1776