xref: /vim-8.2.3635/src/if_python.c (revision e968e36a) 
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 #include "vim.h"
21 
22 #include <limits.h>
23 
24 /* uncomment this if used with the debug version of python.
25  * Checked on 2.7.4. */
26 /* #define Py_DEBUG */
27 /* Note: most of time you can add -DPy_DEBUG to CFLAGS in place of uncommenting
28  */
29 /* uncomment this if used with the debug version of python, but without its
30  * allocator */
31 /* #define Py_DEBUG_NO_PYMALLOC */
32 
33 /* Python.h defines _POSIX_THREADS itself (if needed) */
34 #ifdef _POSIX_THREADS
35 # undef _POSIX_THREADS
36 #endif
37 
38 #if defined(_WIN32) && defined(HAVE_FCNTL_H)
39 # undef HAVE_FCNTL_H
40 #endif
41 
42 #ifdef _DEBUG
43 # undef _DEBUG
44 #endif
45 
46 #ifdef HAVE_STDARG_H
47 # undef HAVE_STDARG_H	/* Python's config.h defines it as well. */
48 #endif
49 #ifdef _POSIX_C_SOURCE
50 # undef _POSIX_C_SOURCE	/* pyconfig.h defines it as well. */
51 #endif
52 #ifdef _XOPEN_SOURCE
53 # undef _XOPEN_SOURCE	/* pyconfig.h defines it as well. */
54 #endif
55 
56 #define PY_SSIZE_T_CLEAN
57 
58 #include <Python.h>
59 
60 #if !defined(PY_VERSION_HEX) || PY_VERSION_HEX < 0x02050000
61 # undef PY_SSIZE_T_CLEAN
62 #endif
63 
64 #if defined(MACOS) && !defined(MACOS_X_UNIX)
65 # include "macglue.h"
66 # include <CodeFragments.h>
67 #endif
68 #undef main /* Defined in python.h - aargh */
69 #undef HAVE_FCNTL_H /* Clash with os_win32.h */
70 
71 #define PyBytes_FromString      PyString_FromString
72 #define PyBytes_Check           PyString_Check
73 #define PyBytes_AsStringAndSize PyString_AsStringAndSize
74 
75 #if !defined(FEAT_PYTHON) && defined(PROTO)
76 /* Use this to be able to generate prototypes without python being used. */
77 # define PyObject Py_ssize_t
78 # define PyThreadState Py_ssize_t
79 # define PyTypeObject Py_ssize_t
80 struct PyMethodDef { Py_ssize_t a; };
81 # define PySequenceMethods Py_ssize_t
82 #endif
83 
84 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000
85 # define PY_USE_CAPSULE
86 #endif
87 
88 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02050000
89 # define PyInt Py_ssize_t
90 # define PyInquiry lenfunc
91 # define PyIntArgFunc ssizeargfunc
92 # define PyIntIntArgFunc ssizessizeargfunc
93 # define PyIntObjArgProc ssizeobjargproc
94 # define PyIntIntObjArgProc ssizessizeobjargproc
95 # define Py_ssize_t_fmt "n"
96 #else
97 # define PyInt int
98 # define lenfunc inquiry
99 # define PyInquiry inquiry
100 # define PyIntArgFunc intargfunc
101 # define PyIntIntArgFunc intintargfunc
102 # define PyIntObjArgProc intobjargproc
103 # define PyIntIntObjArgProc intintobjargproc
104 # define Py_ssize_t_fmt "i"
105 #endif
106 #define Py_bytes_fmt "s"
107 
108 /* Parser flags */
109 #define single_input	256
110 #define file_input	257
111 #define eval_input	258
112 
113 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x020300F0
114   /* Python 2.3: can invoke ":python" recursively. */
115 # define PY_CAN_RECURSE
116 #endif
117 
118 # if defined(DYNAMIC_PYTHON) || defined(PROTO)
119 #  ifndef DYNAMIC_PYTHON
120 #   define HINSTANCE long_u		/* for generating prototypes */
121 #  endif
122 
123 # ifndef WIN3264
124 #  include <dlfcn.h>
125 #  define FARPROC void*
126 #  define HINSTANCE void*
127 #  if defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)
128 #   define load_dll(n) dlopen((n), RTLD_LAZY)
129 #  else
130 #   define load_dll(n) dlopen((n), RTLD_LAZY|RTLD_GLOBAL)
131 #  endif
132 #  define close_dll dlclose
133 #  define symbol_from_dll dlsym
134 # else
135 #  define load_dll vimLoadLib
136 #  define close_dll FreeLibrary
137 #  define symbol_from_dll GetProcAddress
138 # endif
139 
140 /* This makes if_python.c compile without warnings against Python 2.5
141  * on Win32 and Win64. */
142 # undef PyRun_SimpleString
143 # undef PyRun_String
144 # undef PyArg_Parse
145 # undef PyArg_ParseTuple
146 # undef Py_BuildValue
147 # undef Py_InitModule4
148 # undef Py_InitModule4_64
149 # undef PyObject_CallMethod
150 # undef PyObject_CallFunction
151 
152 /*
153  * Wrapper defines
154  */
155 # define PyArg_Parse dll_PyArg_Parse
156 # define PyArg_ParseTuple dll_PyArg_ParseTuple
157 # define PyMem_Free dll_PyMem_Free
158 # define PyMem_Malloc dll_PyMem_Malloc
159 # define PyDict_SetItemString dll_PyDict_SetItemString
160 # define PyErr_BadArgument dll_PyErr_BadArgument
161 # define PyErr_NewException dll_PyErr_NewException
162 # define PyErr_Clear dll_PyErr_Clear
163 # define PyErr_Format dll_PyErr_Format
164 # define PyErr_PrintEx dll_PyErr_PrintEx
165 # define PyErr_NoMemory dll_PyErr_NoMemory
166 # define PyErr_Occurred dll_PyErr_Occurred
167 # define PyErr_SetNone dll_PyErr_SetNone
168 # define PyErr_SetString dll_PyErr_SetString
169 # define PyErr_SetObject dll_PyErr_SetObject
170 # define PyErr_ExceptionMatches dll_PyErr_ExceptionMatches
171 # define PyEval_InitThreads dll_PyEval_InitThreads
172 # define PyEval_RestoreThread dll_PyEval_RestoreThread
173 # define PyEval_SaveThread dll_PyEval_SaveThread
174 # ifdef PY_CAN_RECURSE
175 #  define PyGILState_Ensure dll_PyGILState_Ensure
176 #  define PyGILState_Release dll_PyGILState_Release
177 # endif
178 # define PyInt_AsLong dll_PyInt_AsLong
179 # define PyInt_FromLong dll_PyInt_FromLong
180 # define PyLong_AsLong dll_PyLong_AsLong
181 # define PyLong_FromLong dll_PyLong_FromLong
182 # define PyBool_Type (*dll_PyBool_Type)
183 # define PyInt_Type (*dll_PyInt_Type)
184 # define PyLong_Type (*dll_PyLong_Type)
185 # define PyList_GetItem dll_PyList_GetItem
186 # define PyList_Append dll_PyList_Append
187 # define PyList_Insert dll_PyList_Insert
188 # define PyList_New dll_PyList_New
189 # define PyList_SetItem dll_PyList_SetItem
190 # define PyList_Size dll_PyList_Size
191 # define PyList_Type (*dll_PyList_Type)
192 # define PySequence_Check dll_PySequence_Check
193 # define PySequence_Size dll_PySequence_Size
194 # define PySequence_GetItem dll_PySequence_GetItem
195 # define PySequence_Fast dll_PySequence_Fast
196 # define PyTuple_Size dll_PyTuple_Size
197 # define PyTuple_GetItem dll_PyTuple_GetItem
198 # define PyTuple_Type (*dll_PyTuple_Type)
199 # define PySlice_GetIndicesEx dll_PySlice_GetIndicesEx
200 # define PyImport_ImportModule dll_PyImport_ImportModule
201 # define PyDict_New dll_PyDict_New
202 # define PyDict_GetItemString dll_PyDict_GetItemString
203 # define PyDict_Next dll_PyDict_Next
204 # define PyDict_Type (*dll_PyDict_Type)
205 # ifdef PyMapping_Keys
206 #  define PY_NO_MAPPING_KEYS
207 # else
208 #  define PyMapping_Keys dll_PyMapping_Keys
209 # endif
210 # define PyObject_GetItem dll_PyObject_GetItem
211 # define PyObject_CallMethod dll_PyObject_CallMethod
212 # define PyMapping_Check dll_PyMapping_Check
213 # define PyIter_Next dll_PyIter_Next
214 # define PyModule_GetDict dll_PyModule_GetDict
215 # define PyModule_AddObject dll_PyModule_AddObject
216 # define PyRun_SimpleString dll_PyRun_SimpleString
217 # define PyRun_String dll_PyRun_String
218 # define PyObject_GetAttrString dll_PyObject_GetAttrString
219 # define PyObject_HasAttrString dll_PyObject_HasAttrString
220 # define PyObject_SetAttrString dll_PyObject_SetAttrString
221 # define PyObject_CallFunctionObjArgs dll_PyObject_CallFunctionObjArgs
222 # define PyObject_CallFunction dll_PyObject_CallFunction
223 # define PyObject_Call dll_PyObject_Call
224 # define PyObject_Repr dll_PyObject_Repr
225 # define PyString_AsString dll_PyString_AsString
226 # define PyString_AsStringAndSize dll_PyString_AsStringAndSize
227 # define PyString_FromString dll_PyString_FromString
228 # define PyString_FromFormat dll_PyString_FromFormat
229 # define PyString_FromStringAndSize dll_PyString_FromStringAndSize
230 # define PyString_Size dll_PyString_Size
231 # define PyString_Type (*dll_PyString_Type)
232 # define PyUnicode_Type (*dll_PyUnicode_Type)
233 # undef PyUnicode_AsEncodedString
234 # define PyUnicode_AsEncodedString py_PyUnicode_AsEncodedString
235 # define PyFloat_AsDouble dll_PyFloat_AsDouble
236 # define PyFloat_FromDouble dll_PyFloat_FromDouble
237 # define PyFloat_Type (*dll_PyFloat_Type)
238 # define PyNumber_Check dll_PyNumber_Check
239 # define PyNumber_Long dll_PyNumber_Long
240 # define PyImport_AddModule (*dll_PyImport_AddModule)
241 # define PySys_SetObject dll_PySys_SetObject
242 # define PySys_GetObject dll_PySys_GetObject
243 # define PySys_SetArgv dll_PySys_SetArgv
244 # define PyType_Type (*dll_PyType_Type)
245 # define PySlice_Type (*dll_PySlice_Type)
246 # define PyType_Ready (*dll_PyType_Ready)
247 # define PyType_GenericAlloc dll_PyType_GenericAlloc
248 # define Py_BuildValue dll_Py_BuildValue
249 # define Py_FindMethod dll_Py_FindMethod
250 # define Py_InitModule4 dll_Py_InitModule4
251 # define Py_SetPythonHome dll_Py_SetPythonHome
252 # define Py_Initialize dll_Py_Initialize
253 # define Py_Finalize dll_Py_Finalize
254 # define Py_IsInitialized dll_Py_IsInitialized
255 # define _PyObject_New dll__PyObject_New
256 # define _PyObject_GC_New dll__PyObject_GC_New
257 # ifdef PyObject_GC_Del
258 #  define Py_underscore_GC
259 #  define _PyObject_GC_Del dll__PyObject_GC_Del
260 #  define _PyObject_GC_UnTrack dll__PyObject_GC_UnTrack
261 # else
262 #  define PyObject_GC_Del dll_PyObject_GC_Del
263 #  define PyObject_GC_UnTrack dll_PyObject_GC_UnTrack
264 # endif
265 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000
266 #  define _PyObject_NextNotImplemented (*dll__PyObject_NextNotImplemented)
267 # endif
268 # define _Py_NoneStruct (*dll__Py_NoneStruct)
269 # define _Py_ZeroStruct (*dll__Py_ZeroStruct)
270 # define _Py_TrueStruct (*dll__Py_TrueStruct)
271 # define PyObject_Init dll__PyObject_Init
272 # define PyObject_GetIter dll_PyObject_GetIter
273 # define PyObject_IsTrue dll_PyObject_IsTrue
274 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000
275 #  define PyType_IsSubtype dll_PyType_IsSubtype
276 #  ifdef Py_DEBUG
277 #   define _Py_NegativeRefcount dll__Py_NegativeRefcount
278 #   define _Py_RefTotal (*dll__Py_RefTotal)
279 #   define _Py_Dealloc dll__Py_Dealloc
280 #  endif
281 # endif
282 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000
283 #  if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC)
284 #   define _PyObject_DebugMalloc dll__PyObject_DebugMalloc
285 #   define _PyObject_DebugFree dll__PyObject_DebugFree
286 #  else
287 #   define PyObject_Malloc dll_PyObject_Malloc
288 #   define PyObject_Free dll_PyObject_Free
289 #  endif
290 # endif
291 # ifdef PY_USE_CAPSULE
292 #  define PyCapsule_New dll_PyCapsule_New
293 #  define PyCapsule_GetPointer dll_PyCapsule_GetPointer
294 # else
295 #  define PyCObject_FromVoidPtr dll_PyCObject_FromVoidPtr
296 #  define PyCObject_AsVoidPtr dll_PyCObject_AsVoidPtr
297 # endif
298 
299 /*
300  * Pointers for dynamic link
301  */
302 static int(*dll_PyArg_Parse)(PyObject *, char *, ...);
303 static int(*dll_PyArg_ParseTuple)(PyObject *, char *, ...);
304 static int(*dll_PyMem_Free)(void *);
305 static void* (*dll_PyMem_Malloc)(size_t);
306 static int(*dll_PyDict_SetItemString)(PyObject *dp, char *key, PyObject *item);
307 static int(*dll_PyErr_BadArgument)(void);
308 static PyObject *(*dll_PyErr_NewException)(char *, PyObject *, PyObject *);
309 static void(*dll_PyErr_Clear)(void);
310 static PyObject*(*dll_PyErr_Format)(PyObject *, const char *, ...);
311 static void(*dll_PyErr_PrintEx)(int);
312 static PyObject*(*dll_PyErr_NoMemory)(void);
313 static PyObject*(*dll_PyErr_Occurred)(void);
314 static void(*dll_PyErr_SetNone)(PyObject *);
315 static void(*dll_PyErr_SetString)(PyObject *, const char *);
316 static void(*dll_PyErr_SetObject)(PyObject *, PyObject *);
317 static int(*dll_PyErr_ExceptionMatches)(PyObject *);
318 static void(*dll_PyEval_InitThreads)(void);
319 static void(*dll_PyEval_RestoreThread)(PyThreadState *);
320 static PyThreadState*(*dll_PyEval_SaveThread)(void);
321 # ifdef PY_CAN_RECURSE
322 static PyGILState_STATE	(*dll_PyGILState_Ensure)(void);
323 static void (*dll_PyGILState_Release)(PyGILState_STATE);
324 # endif
325 static long(*dll_PyInt_AsLong)(PyObject *);
326 static PyObject*(*dll_PyInt_FromLong)(long);
327 static long(*dll_PyLong_AsLong)(PyObject *);
328 static PyObject*(*dll_PyLong_FromLong)(long);
329 static PyTypeObject* dll_PyBool_Type;
330 static PyTypeObject* dll_PyInt_Type;
331 static PyTypeObject* dll_PyLong_Type;
332 static PyObject*(*dll_PyList_GetItem)(PyObject *, PyInt);
333 static int(*dll_PyList_Append)(PyObject *, PyObject *);
334 static int(*dll_PyList_Insert)(PyObject *, PyInt, PyObject *);
335 static PyObject*(*dll_PyList_New)(PyInt size);
336 static int(*dll_PyList_SetItem)(PyObject *, PyInt, PyObject *);
337 static PyInt(*dll_PyList_Size)(PyObject *);
338 static PyTypeObject* dll_PyList_Type;
339 static int (*dll_PySequence_Check)(PyObject *);
340 static PyInt(*dll_PySequence_Size)(PyObject *);
341 static PyObject*(*dll_PySequence_GetItem)(PyObject *, PyInt);
342 static PyObject*(*dll_PySequence_Fast)(PyObject *, const char *);
343 static PyInt(*dll_PyTuple_Size)(PyObject *);
344 static PyObject*(*dll_PyTuple_GetItem)(PyObject *, PyInt);
345 static PyTypeObject* dll_PyTuple_Type;
346 static int (*dll_PySlice_GetIndicesEx)(PySliceObject *r, PyInt length,
347 		     PyInt *start, PyInt *stop, PyInt *step,
348 		     PyInt *slicelen);
349 static PyObject*(*dll_PyImport_ImportModule)(const char *);
350 static PyObject*(*dll_PyDict_New)(void);
351 static PyObject*(*dll_PyDict_GetItemString)(PyObject *, const char *);
352 static int (*dll_PyDict_Next)(PyObject *, PyInt *, PyObject **, PyObject **);
353 static PyTypeObject* dll_PyDict_Type;
354 # ifndef PY_NO_MAPPING_KEYS
355 static PyObject* (*dll_PyMapping_Keys)(PyObject *);
356 # endif
357 static PyObject* (*dll_PyObject_GetItem)(PyObject *, PyObject *);
358 static PyObject* (*dll_PyObject_CallMethod)(PyObject *, char *, PyObject *);
359 static int (*dll_PyMapping_Check)(PyObject *);
360 static PyObject* (*dll_PyIter_Next)(PyObject *);
361 static PyObject*(*dll_PyModule_GetDict)(PyObject *);
362 static int(*dll_PyModule_AddObject)(PyObject *, const char *, PyObject *);
363 static int(*dll_PyRun_SimpleString)(char *);
364 static PyObject *(*dll_PyRun_String)(char *, int, PyObject *, PyObject *);
365 static PyObject* (*dll_PyObject_GetAttrString)(PyObject *, const char *);
366 static int (*dll_PyObject_HasAttrString)(PyObject *, const char *);
367 static int (*dll_PyObject_SetAttrString)(PyObject *, const char *, PyObject *);
368 static PyObject* (*dll_PyObject_CallFunctionObjArgs)(PyObject *, ...);
369 static PyObject* (*dll_PyObject_CallFunction)(PyObject *, char *, ...);
370 static PyObject* (*dll_PyObject_Call)(PyObject *, PyObject *, PyObject *);
371 static PyObject* (*dll_PyObject_Repr)(PyObject *);
372 static char*(*dll_PyString_AsString)(PyObject *);
373 static int(*dll_PyString_AsStringAndSize)(PyObject *, char **, PyInt *);
374 static PyObject*(*dll_PyString_FromString)(const char *);
375 static PyObject*(*dll_PyString_FromFormat)(const char *, ...);
376 static PyObject*(*dll_PyString_FromStringAndSize)(const char *, PyInt);
377 static PyInt(*dll_PyString_Size)(PyObject *);
378 static PyTypeObject* dll_PyString_Type;
379 static PyTypeObject* dll_PyUnicode_Type;
380 static PyObject *(*py_PyUnicode_AsEncodedString)(PyObject *, char *, char *);
381 static double(*dll_PyFloat_AsDouble)(PyObject *);
382 static PyObject*(*dll_PyFloat_FromDouble)(double);
383 static PyTypeObject* dll_PyFloat_Type;
384 static int(*dll_PyNumber_Check)(PyObject *);
385 static PyObject*(*dll_PyNumber_Long)(PyObject *);
386 static int(*dll_PySys_SetObject)(char *, PyObject *);
387 static PyObject *(*dll_PySys_GetObject)(char *);
388 static int(*dll_PySys_SetArgv)(int, char **);
389 static PyTypeObject* dll_PyType_Type;
390 static PyTypeObject* dll_PySlice_Type;
391 static int (*dll_PyType_Ready)(PyTypeObject *type);
392 static PyObject* (*dll_PyType_GenericAlloc)(PyTypeObject *type, PyInt nitems);
393 static PyObject*(*dll_Py_BuildValue)(char *, ...);
394 static PyObject*(*dll_Py_FindMethod)(struct PyMethodDef[], PyObject *, char *);
395 static PyObject*(*dll_Py_InitModule4)(char *, struct PyMethodDef *, char *, PyObject *, int);
396 static PyObject*(*dll_PyImport_AddModule)(char *);
397 static void(*dll_Py_SetPythonHome)(char *home);
398 static void(*dll_Py_Initialize)(void);
399 static void(*dll_Py_Finalize)(void);
400 static int(*dll_Py_IsInitialized)(void);
401 static PyObject*(*dll__PyObject_New)(PyTypeObject *, PyObject *);
402 static PyObject*(*dll__PyObject_GC_New)(PyTypeObject *);
403 # ifdef Py_underscore_GC
404 static void(*dll__PyObject_GC_Del)(void *);
405 static void(*dll__PyObject_GC_UnTrack)(void *);
406 # else
407 static void(*dll_PyObject_GC_Del)(void *);
408 static void(*dll_PyObject_GC_UnTrack)(void *);
409 # endif
410 static PyObject*(*dll__PyObject_Init)(PyObject *, PyTypeObject *);
411 static PyObject* (*dll_PyObject_GetIter)(PyObject *);
412 static int (*dll_PyObject_IsTrue)(PyObject *);
413 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000
414 static iternextfunc dll__PyObject_NextNotImplemented;
415 # endif
416 static PyObject* dll__Py_NoneStruct;
417 static PyObject* _Py_ZeroStruct;
418 static PyObject* dll__Py_TrueStruct;
419 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000
420 static int (*dll_PyType_IsSubtype)(PyTypeObject *, PyTypeObject *);
421 #  ifdef Py_DEBUG
422 static void (*dll__Py_NegativeRefcount)(const char *fname, int lineno, PyObject *op);
423 static PyInt* dll__Py_RefTotal;
424 static void (*dll__Py_Dealloc)(PyObject *obj);
425 #  endif
426 # endif
427 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000
428 #  if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC)
429 static void (*dll__PyObject_DebugFree)(void*);
430 static void* (*dll__PyObject_DebugMalloc)(size_t);
431 #  else
432 static void* (*dll_PyObject_Malloc)(size_t);
433 static void (*dll_PyObject_Free)(void*);
434 #  endif
435 # endif
436 # ifdef PY_USE_CAPSULE
437 static PyObject* (*dll_PyCapsule_New)(void *, char *, PyCapsule_Destructor);
438 static void* (*dll_PyCapsule_GetPointer)(PyObject *, char *);
439 # else
440 static PyObject* (*dll_PyCObject_FromVoidPtr)(void *cobj, void (*destr)(void *));
441 static void* (*dll_PyCObject_AsVoidPtr)(PyObject *);
442 # endif
443 
444 static HINSTANCE hinstPython = 0; /* Instance of python.dll */
445 
446 /* Imported exception objects */
447 static PyObject *imp_PyExc_AttributeError;
448 static PyObject *imp_PyExc_IndexError;
449 static PyObject *imp_PyExc_KeyError;
450 static PyObject *imp_PyExc_KeyboardInterrupt;
451 static PyObject *imp_PyExc_TypeError;
452 static PyObject *imp_PyExc_ValueError;
453 static PyObject *imp_PyExc_SystemExit;
454 static PyObject *imp_PyExc_RuntimeError;
455 static PyObject *imp_PyExc_ImportError;
456 static PyObject *imp_PyExc_OverflowError;
457 
458 # define PyExc_AttributeError imp_PyExc_AttributeError
459 # define PyExc_IndexError imp_PyExc_IndexError
460 # define PyExc_KeyError imp_PyExc_KeyError
461 # define PyExc_KeyboardInterrupt imp_PyExc_KeyboardInterrupt
462 # define PyExc_TypeError imp_PyExc_TypeError
463 # define PyExc_ValueError imp_PyExc_ValueError
464 # define PyExc_SystemExit imp_PyExc_SystemExit
465 # define PyExc_RuntimeError imp_PyExc_RuntimeError
466 # define PyExc_ImportError imp_PyExc_ImportError
467 # define PyExc_OverflowError imp_PyExc_OverflowError
468 
469 /*
470  * Table of name to function pointer of python.
471  */
472 # define PYTHON_PROC FARPROC
473 static struct
474 {
475     char *name;
476     PYTHON_PROC *ptr;
477 } python_funcname_table[] =
478 {
479 #ifndef PY_SSIZE_T_CLEAN
480     {"PyArg_Parse", (PYTHON_PROC*)&dll_PyArg_Parse},
481     {"PyArg_ParseTuple", (PYTHON_PROC*)&dll_PyArg_ParseTuple},
482     {"Py_BuildValue", (PYTHON_PROC*)&dll_Py_BuildValue},
483 #else
484     {"_PyArg_Parse_SizeT", (PYTHON_PROC*)&dll_PyArg_Parse},
485     {"_PyArg_ParseTuple_SizeT", (PYTHON_PROC*)&dll_PyArg_ParseTuple},
486     {"_Py_BuildValue_SizeT", (PYTHON_PROC*)&dll_Py_BuildValue},
487 #endif
488     {"PyMem_Free", (PYTHON_PROC*)&dll_PyMem_Free},
489     {"PyMem_Malloc", (PYTHON_PROC*)&dll_PyMem_Malloc},
490     {"PyDict_SetItemString", (PYTHON_PROC*)&dll_PyDict_SetItemString},
491     {"PyErr_BadArgument", (PYTHON_PROC*)&dll_PyErr_BadArgument},
492     {"PyErr_NewException", (PYTHON_PROC*)&dll_PyErr_NewException},
493     {"PyErr_Clear", (PYTHON_PROC*)&dll_PyErr_Clear},
494     {"PyErr_Format", (PYTHON_PROC*)&dll_PyErr_Format},
495     {"PyErr_PrintEx", (PYTHON_PROC*)&dll_PyErr_PrintEx},
496     {"PyErr_NoMemory", (PYTHON_PROC*)&dll_PyErr_NoMemory},
497     {"PyErr_Occurred", (PYTHON_PROC*)&dll_PyErr_Occurred},
498     {"PyErr_SetNone", (PYTHON_PROC*)&dll_PyErr_SetNone},
499     {"PyErr_SetString", (PYTHON_PROC*)&dll_PyErr_SetString},
500     {"PyErr_SetObject", (PYTHON_PROC*)&dll_PyErr_SetObject},
501     {"PyErr_ExceptionMatches", (PYTHON_PROC*)&dll_PyErr_ExceptionMatches},
502     {"PyEval_InitThreads", (PYTHON_PROC*)&dll_PyEval_InitThreads},
503     {"PyEval_RestoreThread", (PYTHON_PROC*)&dll_PyEval_RestoreThread},
504     {"PyEval_SaveThread", (PYTHON_PROC*)&dll_PyEval_SaveThread},
505 # ifdef PY_CAN_RECURSE
506     {"PyGILState_Ensure", (PYTHON_PROC*)&dll_PyGILState_Ensure},
507     {"PyGILState_Release", (PYTHON_PROC*)&dll_PyGILState_Release},
508 # endif
509     {"PyInt_AsLong", (PYTHON_PROC*)&dll_PyInt_AsLong},
510     {"PyInt_FromLong", (PYTHON_PROC*)&dll_PyInt_FromLong},
511     {"PyLong_AsLong", (PYTHON_PROC*)&dll_PyLong_AsLong},
512     {"PyLong_FromLong", (PYTHON_PROC*)&dll_PyLong_FromLong},
513     {"PyBool_Type", (PYTHON_PROC*)&dll_PyBool_Type},
514     {"PyInt_Type", (PYTHON_PROC*)&dll_PyInt_Type},
515     {"PyLong_Type", (PYTHON_PROC*)&dll_PyLong_Type},
516     {"PyList_GetItem", (PYTHON_PROC*)&dll_PyList_GetItem},
517     {"PyList_Append", (PYTHON_PROC*)&dll_PyList_Append},
518     {"PyList_Insert", (PYTHON_PROC*)&dll_PyList_Insert},
519     {"PyList_New", (PYTHON_PROC*)&dll_PyList_New},
520     {"PyList_SetItem", (PYTHON_PROC*)&dll_PyList_SetItem},
521     {"PyList_Size", (PYTHON_PROC*)&dll_PyList_Size},
522     {"PyList_Type", (PYTHON_PROC*)&dll_PyList_Type},
523     {"PySequence_Size", (PYTHON_PROC*)&dll_PySequence_Size},
524     {"PySequence_Check", (PYTHON_PROC*)&dll_PySequence_Check},
525     {"PySequence_GetItem", (PYTHON_PROC*)&dll_PySequence_GetItem},
526     {"PySequence_Fast", (PYTHON_PROC*)&dll_PySequence_Fast},
527     {"PyTuple_GetItem", (PYTHON_PROC*)&dll_PyTuple_GetItem},
528     {"PyTuple_Size", (PYTHON_PROC*)&dll_PyTuple_Size},
529     {"PyTuple_Type", (PYTHON_PROC*)&dll_PyTuple_Type},
530     {"PySlice_GetIndicesEx", (PYTHON_PROC*)&dll_PySlice_GetIndicesEx},
531     {"PyImport_ImportModule", (PYTHON_PROC*)&dll_PyImport_ImportModule},
532     {"PyDict_GetItemString", (PYTHON_PROC*)&dll_PyDict_GetItemString},
533     {"PyDict_Next", (PYTHON_PROC*)&dll_PyDict_Next},
534     {"PyDict_New", (PYTHON_PROC*)&dll_PyDict_New},
535     {"PyDict_Type", (PYTHON_PROC*)&dll_PyDict_Type},
536 # ifndef PY_NO_MAPPING_KEYS
537     {"PyMapping_Keys", (PYTHON_PROC*)&dll_PyMapping_Keys},
538 # endif
539     {"PyObject_GetItem", (PYTHON_PROC*)&dll_PyObject_GetItem},
540     {"PyObject_CallMethod", (PYTHON_PROC*)&dll_PyObject_CallMethod},
541     {"PyMapping_Check", (PYTHON_PROC*)&dll_PyMapping_Check},
542     {"PyIter_Next", (PYTHON_PROC*)&dll_PyIter_Next},
543     {"PyModule_GetDict", (PYTHON_PROC*)&dll_PyModule_GetDict},
544     {"PyModule_AddObject", (PYTHON_PROC*)&dll_PyModule_AddObject},
545     {"PyRun_SimpleString", (PYTHON_PROC*)&dll_PyRun_SimpleString},
546     {"PyRun_String", (PYTHON_PROC*)&dll_PyRun_String},
547     {"PyObject_GetAttrString", (PYTHON_PROC*)&dll_PyObject_GetAttrString},
548     {"PyObject_HasAttrString", (PYTHON_PROC*)&dll_PyObject_HasAttrString},
549     {"PyObject_SetAttrString", (PYTHON_PROC*)&dll_PyObject_SetAttrString},
550     {"PyObject_CallFunctionObjArgs", (PYTHON_PROC*)&dll_PyObject_CallFunctionObjArgs},
551     {"PyObject_CallFunction", (PYTHON_PROC*)&dll_PyObject_CallFunction},
552     {"PyObject_Call", (PYTHON_PROC*)&dll_PyObject_Call},
553     {"PyObject_Repr", (PYTHON_PROC*)&dll_PyObject_Repr},
554     {"PyString_AsString", (PYTHON_PROC*)&dll_PyString_AsString},
555     {"PyString_AsStringAndSize", (PYTHON_PROC*)&dll_PyString_AsStringAndSize},
556     {"PyString_FromString", (PYTHON_PROC*)&dll_PyString_FromString},
557     {"PyString_FromFormat", (PYTHON_PROC*)&dll_PyString_FromFormat},
558     {"PyString_FromStringAndSize", (PYTHON_PROC*)&dll_PyString_FromStringAndSize},
559     {"PyString_Size", (PYTHON_PROC*)&dll_PyString_Size},
560     {"PyString_Type", (PYTHON_PROC*)&dll_PyString_Type},
561     {"PyUnicode_Type", (PYTHON_PROC*)&dll_PyUnicode_Type},
562     {"PyFloat_Type", (PYTHON_PROC*)&dll_PyFloat_Type},
563     {"PyFloat_AsDouble", (PYTHON_PROC*)&dll_PyFloat_AsDouble},
564     {"PyFloat_FromDouble", (PYTHON_PROC*)&dll_PyFloat_FromDouble},
565     {"PyImport_AddModule", (PYTHON_PROC*)&dll_PyImport_AddModule},
566     {"PyNumber_Check", (PYTHON_PROC*)&dll_PyNumber_Check},
567     {"PyNumber_Long", (PYTHON_PROC*)&dll_PyNumber_Long},
568     {"PySys_SetObject", (PYTHON_PROC*)&dll_PySys_SetObject},
569     {"PySys_GetObject", (PYTHON_PROC*)&dll_PySys_GetObject},
570     {"PySys_SetArgv", (PYTHON_PROC*)&dll_PySys_SetArgv},
571     {"PyType_Type", (PYTHON_PROC*)&dll_PyType_Type},
572     {"PySlice_Type", (PYTHON_PROC*)&dll_PySlice_Type},
573     {"PyType_Ready", (PYTHON_PROC*)&dll_PyType_Ready},
574     {"PyType_GenericAlloc", (PYTHON_PROC*)&dll_PyType_GenericAlloc},
575     {"Py_FindMethod", (PYTHON_PROC*)&dll_Py_FindMethod},
576     {"Py_SetPythonHome", (PYTHON_PROC*)&dll_Py_SetPythonHome},
577     {"Py_Initialize", (PYTHON_PROC*)&dll_Py_Initialize},
578     {"Py_Finalize", (PYTHON_PROC*)&dll_Py_Finalize},
579     {"Py_IsInitialized", (PYTHON_PROC*)&dll_Py_IsInitialized},
580     {"_PyObject_New", (PYTHON_PROC*)&dll__PyObject_New},
581     {"_PyObject_GC_New", (PYTHON_PROC*)&dll__PyObject_GC_New},
582 # ifdef Py_underscore_GC
583     {"_PyObject_GC_Del", (PYTHON_PROC*)&dll__PyObject_GC_Del},
584     {"_PyObject_GC_UnTrack", (PYTHON_PROC*)&dll__PyObject_GC_UnTrack},
585 # else
586     {"PyObject_GC_Del", (PYTHON_PROC*)&dll_PyObject_GC_Del},
587     {"PyObject_GC_UnTrack", (PYTHON_PROC*)&dll_PyObject_GC_UnTrack},
588 # endif
589     {"PyObject_Init", (PYTHON_PROC*)&dll__PyObject_Init},
590     {"PyObject_GetIter", (PYTHON_PROC*)&dll_PyObject_GetIter},
591     {"PyObject_IsTrue", (PYTHON_PROC*)&dll_PyObject_IsTrue},
592 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000
593     {"_PyObject_NextNotImplemented", (PYTHON_PROC*)&dll__PyObject_NextNotImplemented},
594 # endif
595     {"_Py_NoneStruct", (PYTHON_PROC*)&dll__Py_NoneStruct},
596     {"_Py_ZeroStruct", (PYTHON_PROC*)&dll__Py_ZeroStruct},
597     {"_Py_TrueStruct", (PYTHON_PROC*)&dll__Py_TrueStruct},
598 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000
599 #  ifdef Py_DEBUG
600     {"_Py_NegativeRefcount", (PYTHON_PROC*)&dll__Py_NegativeRefcount},
601     {"_Py_RefTotal", (PYTHON_PROC*)&dll__Py_RefTotal},
602     {"_Py_Dealloc", (PYTHON_PROC*)&dll__Py_Dealloc},
603 #  endif
604     {"PyType_IsSubtype", (PYTHON_PROC*)&dll_PyType_IsSubtype},
605 # endif
606 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000
607 #  if defined(Py_DEBUG) && !defined(Py_DEBUG_NO_PYMALLOC)
608     {"_PyObject_DebugFree", (PYTHON_PROC*)&dll__PyObject_DebugFree},
609     {"_PyObject_DebugMalloc", (PYTHON_PROC*)&dll__PyObject_DebugMalloc},
610 #  else
611     {"PyObject_Malloc", (PYTHON_PROC*)&dll_PyObject_Malloc},
612     {"PyObject_Free", (PYTHON_PROC*)&dll_PyObject_Free},
613 #  endif
614 # endif
615 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02050000 \
616 	&& SIZEOF_SIZE_T != VIM_SIZEOF_INT
617 #  ifdef Py_DEBUG
618     {"Py_InitModule4TraceRefs_64", (PYTHON_PROC*)&dll_Py_InitModule4},
619 #  else
620     {"Py_InitModule4_64", (PYTHON_PROC*)&dll_Py_InitModule4},
621 #  endif
622 # else
623 #  ifdef Py_DEBUG
624     {"Py_InitModule4TraceRefs", (PYTHON_PROC*)&dll_Py_InitModule4},
625 #  else
626     {"Py_InitModule4", (PYTHON_PROC*)&dll_Py_InitModule4},
627 #  endif
628 # endif
629 # ifdef PY_USE_CAPSULE
630     {"PyCapsule_New", (PYTHON_PROC*)&dll_PyCapsule_New},
631     {"PyCapsule_GetPointer", (PYTHON_PROC*)&dll_PyCapsule_GetPointer},
632 # else
633     {"PyCObject_FromVoidPtr", (PYTHON_PROC*)&dll_PyCObject_FromVoidPtr},
634     {"PyCObject_AsVoidPtr", (PYTHON_PROC*)&dll_PyCObject_AsVoidPtr},
635 # endif
636     {"", NULL},
637 };
638 
639 /*
640  * Free python.dll
641  */
642     static void
643 end_dynamic_python(void)
644 {
645     if (hinstPython)
646     {
647 	close_dll(hinstPython);
648 	hinstPython = 0;
649     }
650 }
651 
652 /*
653  * Load library and get all pointers.
654  * Parameter 'libname' provides name of DLL.
655  * Return OK or FAIL.
656  */
657     static int
658 python_runtime_link_init(char *libname, int verbose)
659 {
660     int i;
661     void *ucs_as_encoded_string;
662 
663 #if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON3)
664     /* Can't have Python and Python3 loaded at the same time.
665      * It cause a crash, because RTLD_GLOBAL is needed for
666      * standard C extension libraries of one or both python versions. */
667     if (python3_loaded())
668     {
669 	if (verbose)
670 	    EMSG(_("E836: This Vim cannot execute :python after using :py3"));
671 	return FAIL;
672     }
673 #endif
674 
675     if (hinstPython)
676 	return OK;
677     hinstPython = load_dll(libname);
678     if (!hinstPython)
679     {
680 	if (verbose)
681 	    EMSG2(_(e_loadlib), libname);
682 	return FAIL;
683     }
684 
685     for (i = 0; python_funcname_table[i].ptr; ++i)
686     {
687 	if ((*python_funcname_table[i].ptr = symbol_from_dll(hinstPython,
688 			python_funcname_table[i].name)) == NULL)
689 	{
690 	    close_dll(hinstPython);
691 	    hinstPython = 0;
692 	    if (verbose)
693 		EMSG2(_(e_loadfunc), python_funcname_table[i].name);
694 	    return FAIL;
695 	}
696     }
697 
698     /* Load unicode functions separately as only the ucs2 or the ucs4 functions
699      * will be present in the library. */
700     ucs_as_encoded_string = symbol_from_dll(hinstPython,
701 					     "PyUnicodeUCS2_AsEncodedString");
702     if (ucs_as_encoded_string == NULL)
703 	ucs_as_encoded_string = symbol_from_dll(hinstPython,
704 					     "PyUnicodeUCS4_AsEncodedString");
705     if (ucs_as_encoded_string != NULL)
706 	py_PyUnicode_AsEncodedString = ucs_as_encoded_string;
707     else
708     {
709 	close_dll(hinstPython);
710 	hinstPython = 0;
711 	if (verbose)
712 	    EMSG2(_(e_loadfunc), "PyUnicode_UCSX_*");
713 	return FAIL;
714     }
715 
716     return OK;
717 }
718 
719 /*
720  * If python is enabled (there is installed python on Windows system) return
721  * TRUE, else FALSE.
722  */
723     int
724 python_enabled(int verbose)
725 {
726     return python_runtime_link_init(DYNAMIC_PYTHON_DLL, verbose) == OK;
727 }
728 
729 /*
730  * Load the standard Python exceptions - don't import the symbols from the
731  * DLL, as this can cause errors (importing data symbols is not reliable).
732  */
733     static void
734 get_exceptions(void)
735 {
736     PyObject *exmod = PyImport_ImportModule("exceptions");
737     PyObject *exdict = PyModule_GetDict(exmod);
738     imp_PyExc_AttributeError = PyDict_GetItemString(exdict, "AttributeError");
739     imp_PyExc_IndexError = PyDict_GetItemString(exdict, "IndexError");
740     imp_PyExc_KeyError = PyDict_GetItemString(exdict, "KeyError");
741     imp_PyExc_KeyboardInterrupt = PyDict_GetItemString(exdict, "KeyboardInterrupt");
742     imp_PyExc_TypeError = PyDict_GetItemString(exdict, "TypeError");
743     imp_PyExc_ValueError = PyDict_GetItemString(exdict, "ValueError");
744     imp_PyExc_SystemExit = PyDict_GetItemString(exdict, "SystemExit");
745     imp_PyExc_RuntimeError = PyDict_GetItemString(exdict, "RuntimeError");
746     imp_PyExc_ImportError = PyDict_GetItemString(exdict, "ImportError");
747     imp_PyExc_OverflowError = PyDict_GetItemString(exdict, "OverflowError");
748     Py_XINCREF(imp_PyExc_AttributeError);
749     Py_XINCREF(imp_PyExc_IndexError);
750     Py_XINCREF(imp_PyExc_KeyError);
751     Py_XINCREF(imp_PyExc_KeyboardInterrupt);
752     Py_XINCREF(imp_PyExc_TypeError);
753     Py_XINCREF(imp_PyExc_ValueError);
754     Py_XINCREF(imp_PyExc_SystemExit);
755     Py_XINCREF(imp_PyExc_RuntimeError);
756     Py_XINCREF(imp_PyExc_ImportError);
757     Py_XINCREF(imp_PyExc_OverflowError);
758     Py_XDECREF(exmod);
759 }
760 #endif /* DYNAMIC_PYTHON */
761 
762 static int initialised = 0;
763 #define PYINITIALISED initialised
764 
765 #define DESTRUCTOR_FINISH(self) self->ob_type->tp_free((PyObject*)self);
766 
767 #define WIN_PYTHON_REF(win) win->w_python_ref
768 #define BUF_PYTHON_REF(buf) buf->b_python_ref
769 #define TAB_PYTHON_REF(tab) tab->tp_python_ref
770 
771 static PyObject *OutputGetattr(PyObject *, char *);
772 static PyObject *BufferGetattr(PyObject *, char *);
773 static PyObject *WindowGetattr(PyObject *, char *);
774 static PyObject *TabPageGetattr(PyObject *, char *);
775 static PyObject *RangeGetattr(PyObject *, char *);
776 static PyObject *DictionaryGetattr(PyObject *, char*);
777 static PyObject *ListGetattr(PyObject *, char *);
778 static PyObject *FunctionGetattr(PyObject *, char *);
779 
780 #ifndef Py_VISIT
781 # define Py_VISIT(obj) visit(obj, arg)
782 #endif
783 #ifndef Py_CLEAR
784 # define Py_CLEAR(obj) \
785     { \
786 	Py_XDECREF(obj); \
787 	obj = NULL; \
788     }
789 #endif
790 
791 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
792     static void *
793 py_memsave(void *p, size_t len)
794 {
795     void	*r;
796 
797     if (!(r = PyMem_Malloc(len)))
798 	return NULL;
799     mch_memmove(r, p, len);
800     return r;
801 }
802 
803 # define PY_STRSAVE(s) ((char_u *) py_memsave(s, STRLEN(s) + 1))
804 #endif
805 
806 typedef PySliceObject PySliceObject_T;
807 
808 /*
809  * Include the code shared with if_python3.c
810  */
811 #include "if_py_both.h"
812 
813 
814 /******************************************************
815  * Internal function prototypes.
816  */
817 
818 static int PythonMod_Init(void);
819 
820 
821 /******************************************************
822  * 1. Python interpreter main program.
823  */
824 
825 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */
826 typedef PyObject PyThreadState;
827 #endif
828 
829 #ifndef PY_CAN_RECURSE
830 static PyThreadState *saved_python_thread = NULL;
831 
832 /*
833  * Suspend a thread of the Python interpreter, other threads are allowed to
834  * run.
835  */
836     static void
837 Python_SaveThread(void)
838 {
839     saved_python_thread = PyEval_SaveThread();
840 }
841 
842 /*
843  * Restore a thread of the Python interpreter, waits for other threads to
844  * block.
845  */
846     static void
847 Python_RestoreThread(void)
848 {
849     PyEval_RestoreThread(saved_python_thread);
850     saved_python_thread = NULL;
851 }
852 #endif
853 
854     void
855 python_end()
856 {
857     static int recurse = 0;
858 
859     /* If a crash occurs while doing this, don't try again. */
860     if (recurse != 0)
861 	return;
862 
863     ++recurse;
864 
865 #ifdef DYNAMIC_PYTHON
866     if (hinstPython && Py_IsInitialized())
867     {
868 # ifdef PY_CAN_RECURSE
869 	PyGILState_Ensure();
870 # else
871 	Python_RestoreThread();	    /* enter python */
872 # endif
873 	Py_Finalize();
874     }
875     end_dynamic_python();
876 #else
877     if (Py_IsInitialized())
878     {
879 # ifdef PY_CAN_RECURSE
880 	PyGILState_Ensure();
881 # else
882 	Python_RestoreThread();	    /* enter python */
883 # endif
884 	Py_Finalize();
885     }
886 #endif
887 
888     --recurse;
889 }
890 
891 #if (defined(DYNAMIC_PYTHON) && defined(FEAT_PYTHON3)) || defined(PROTO)
892     int
893 python_loaded()
894 {
895     return (hinstPython != 0);
896 }
897 #endif
898 
899     static int
900 Python_Init(void)
901 {
902     if (!initialised)
903     {
904 #ifdef DYNAMIC_PYTHON
905 	if (!python_enabled(TRUE))
906 	{
907 	    EMSG(_("E263: Sorry, this command is disabled, the Python library could not be loaded."));
908 	    goto fail;
909 	}
910 #endif
911 
912 #ifdef PYTHON_HOME
913 	Py_SetPythonHome(PYTHON_HOME);
914 #endif
915 
916 	init_structs();
917 
918 #if !defined(MACOS) || defined(MACOS_X_UNIX)
919 	Py_Initialize();
920 #else
921 	PyMac_Initialize();
922 #endif
923 	/* Initialise threads, and below save the state using
924 	 * PyEval_SaveThread.  Without the call to PyEval_SaveThread, thread
925 	 * specific state (such as the system trace hook), will be lost
926 	 * between invocations of Python code. */
927 	PyEval_InitThreads();
928 #ifdef DYNAMIC_PYTHON
929 	get_exceptions();
930 #endif
931 
932 	if (PythonIO_Init_io())
933 	    goto fail;
934 
935 	if (PythonMod_Init())
936 	    goto fail;
937 
938 	globals = PyModule_GetDict(PyImport_AddModule("__main__"));
939 
940 	/* Remove the element from sys.path that was added because of our
941 	 * argv[0] value in PythonMod_Init().  Previously we used an empty
942 	 * string, but depending on the OS we then get an empty entry or
943 	 * the current directory in sys.path. */
944 	PyRun_SimpleString("import sys; sys.path = filter(lambda x: x != '/must>not&exist', sys.path)");
945 
946 	/* lock is created and acquired in PyEval_InitThreads() and thread
947 	 * state is created in Py_Initialize()
948 	 * there _PyGILState_NoteThreadState() also sets gilcounter to 1
949 	 * (python must have threads enabled!)
950 	 * so the following does both: unlock GIL and save thread state in TLS
951 	 * without deleting thread state
952 	 */
953 #ifndef PY_CAN_RECURSE
954 	saved_python_thread =
955 #endif
956 	    PyEval_SaveThread();
957 
958 	initialised = 1;
959     }
960 
961     return 0;
962 
963 fail:
964     /* We call PythonIO_Flush() here to print any Python errors.
965      * This is OK, as it is possible to call this function even
966      * if PythonIO_Init_io() has not completed successfully (it will
967      * not do anything in this case).
968      */
969     PythonIO_Flush();
970     return -1;
971 }
972 
973 /*
974  * External interface
975  */
976     static void
977 DoPyCommand(const char *cmd, rangeinitializer init_range, runner run, void *arg)
978 {
979 #ifndef PY_CAN_RECURSE
980     static int		recursive = 0;
981 #endif
982 #if defined(MACOS) && !defined(MACOS_X_UNIX)
983     GrafPtr		oldPort;
984 #endif
985 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
986     char		*saved_locale;
987 #endif
988 #ifdef PY_CAN_RECURSE
989     PyGILState_STATE	pygilstate;
990 #endif
991 
992 #ifndef PY_CAN_RECURSE
993     if (recursive)
994     {
995 	EMSG(_("E659: Cannot invoke Python recursively"));
996 	return;
997     }
998     ++recursive;
999 #endif
1000 
1001 #if defined(MACOS) && !defined(MACOS_X_UNIX)
1002     GetPort(&oldPort);
1003     /* Check if the Python library is available */
1004     if ((Ptr)PyMac_Initialize == (Ptr)kUnresolvedCFragSymbolAddress)
1005 	goto theend;
1006 #endif
1007     if (Python_Init())
1008 	goto theend;
1009 
1010     init_range(arg);
1011 
1012     Python_Release_Vim();	    /* leave vim */
1013 
1014 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
1015     /* Python only works properly when the LC_NUMERIC locale is "C". */
1016     saved_locale = setlocale(LC_NUMERIC, NULL);
1017     if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0)
1018 	saved_locale = NULL;
1019     else
1020     {
1021 	/* Need to make a copy, value may change when setting new locale. */
1022 	saved_locale = (char *) PY_STRSAVE(saved_locale);
1023 	(void)setlocale(LC_NUMERIC, "C");
1024     }
1025 #endif
1026 
1027 #ifdef PY_CAN_RECURSE
1028     pygilstate = PyGILState_Ensure();
1029 #else
1030     Python_RestoreThread();	    /* enter python */
1031 #endif
1032 
1033     run((char *) cmd, arg
1034 #ifdef PY_CAN_RECURSE
1035 	    , &pygilstate
1036 #endif
1037 	    );
1038 
1039 #ifdef PY_CAN_RECURSE
1040     PyGILState_Release(pygilstate);
1041 #else
1042     Python_SaveThread();	    /* leave python */
1043 #endif
1044 
1045 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
1046     if (saved_locale != NULL)
1047     {
1048 	(void)setlocale(LC_NUMERIC, saved_locale);
1049 	PyMem_Free(saved_locale);
1050     }
1051 #endif
1052 
1053     Python_Lock_Vim();		    /* enter vim */
1054     PythonIO_Flush();
1055 #if defined(MACOS) && !defined(MACOS_X_UNIX)
1056     SetPort(oldPort);
1057 #endif
1058 
1059 theend:
1060 #ifndef PY_CAN_RECURSE
1061     --recursive;
1062 #endif
1063     return;
1064 }
1065 
1066 /*
1067  * ":python"
1068  */
1069     void
1070 ex_python(exarg_T *eap)
1071 {
1072     char_u *script;
1073 
1074     script = script_get(eap, eap->arg);
1075     if (!eap->skip)
1076     {
1077 	DoPyCommand(script == NULL ? (char *) eap->arg : (char *) script,
1078 		(rangeinitializer) init_range_cmd,
1079 		(runner) run_cmd,
1080 		(void *) eap);
1081     }
1082     vim_free(script);
1083 }
1084 
1085 #define BUFFER_SIZE 1024
1086 
1087 /*
1088  * ":pyfile"
1089  */
1090     void
1091 ex_pyfile(exarg_T *eap)
1092 {
1093     static char buffer[BUFFER_SIZE];
1094     const char *file = (char *)eap->arg;
1095     char *p;
1096 
1097     /* Have to do it like this. PyRun_SimpleFile requires you to pass a
1098      * stdio file pointer, but Vim and the Python DLL are compiled with
1099      * different options under Windows, meaning that stdio pointers aren't
1100      * compatible between the two. Yuk.
1101      *
1102      * Put the string "execfile('file')" into buffer. But, we need to
1103      * escape any backslashes or single quotes in the file name, so that
1104      * Python won't mangle the file name.
1105      */
1106     strcpy(buffer, "execfile('");
1107     p = buffer + 10; /* size of "execfile('" */
1108 
1109     while (*file && p < buffer + (BUFFER_SIZE - 3))
1110     {
1111 	if (*file == '\\' || *file == '\'')
1112 	    *p++ = '\\';
1113 	*p++ = *file++;
1114     }
1115 
1116     /* If we didn't finish the file name, we hit a buffer overflow */
1117     if (*file != '\0')
1118 	return;
1119 
1120     /* Put in the terminating "')" and a null */
1121     *p++ = '\'';
1122     *p++ = ')';
1123     *p++ = '\0';
1124 
1125     /* Execute the file */
1126     DoPyCommand(buffer,
1127 	    (rangeinitializer) init_range_cmd,
1128 	    (runner) run_cmd,
1129 	    (void *) eap);
1130 }
1131 
1132     void
1133 ex_pydo(exarg_T *eap)
1134 {
1135     DoPyCommand((char *)eap->arg,
1136 	    (rangeinitializer) init_range_cmd,
1137 	    (runner)run_do,
1138 	    (void *)eap);
1139 }
1140 
1141 /******************************************************
1142  * 2. Python output stream: writes output via [e]msg().
1143  */
1144 
1145 /* Implementation functions
1146  */
1147 
1148     static PyObject *
1149 OutputGetattr(PyObject *self, char *name)
1150 {
1151     if (strcmp(name, "softspace") == 0)
1152 	return PyInt_FromLong(((OutputObject *)(self))->softspace);
1153     else if (strcmp(name, "__members__") == 0)
1154 	return ObjectDir(NULL, OutputAttrs);
1155 
1156     return Py_FindMethod(OutputMethods, self, name);
1157 }
1158 
1159 /******************************************************
1160  * 3. Implementation of the Vim module for Python
1161  */
1162 
1163 /* Window type - Implementation functions
1164  * --------------------------------------
1165  */
1166 
1167 #define WindowType_Check(obj) ((obj)->ob_type == &WindowType)
1168 
1169 /* Buffer type - Implementation functions
1170  * --------------------------------------
1171  */
1172 
1173 #define BufferType_Check(obj) ((obj)->ob_type == &BufferType)
1174 
1175 static PyInt BufferAssItem(PyObject *, PyInt, PyObject *);
1176 static PyInt BufferAssSlice(PyObject *, PyInt, PyInt, PyObject *);
1177 
1178 /* Line range type - Implementation functions
1179  * --------------------------------------
1180  */
1181 
1182 #define RangeType_Check(obj) ((obj)->ob_type == &RangeType)
1183 
1184 static PyInt RangeAssItem(PyObject *, PyInt, PyObject *);
1185 static PyInt RangeAssSlice(PyObject *, PyInt, PyInt, PyObject *);
1186 
1187 /* Current objects type - Implementation functions
1188  * -----------------------------------------------
1189  */
1190 
1191 static PySequenceMethods BufferAsSeq = {
1192     (PyInquiry)		BufferLength,	    /* sq_length,    len(x)   */
1193     (binaryfunc)	0,		    /* BufferConcat, sq_concat, x+y */
1194     (PyIntArgFunc)	0,		    /* BufferRepeat, sq_repeat, x*n */
1195     (PyIntArgFunc)	BufferItem,	    /* sq_item,      x[i]     */
1196     (PyIntIntArgFunc)	BufferSlice,	    /* sq_slice,     x[i:j]   */
1197     (PyIntObjArgProc)	BufferAssItem,	    /* sq_ass_item,  x[i]=v   */
1198     (PyIntIntObjArgProc) BufferAssSlice,    /* sq_ass_slice, x[i:j]=v */
1199     (objobjproc)	0,
1200     (binaryfunc)	0,
1201     0,
1202 };
1203 
1204 /* Buffer object - Implementation
1205  */
1206 
1207     static PyObject *
1208 BufferGetattr(PyObject *self, char *name)
1209 {
1210     PyObject *r;
1211 
1212     if ((r = BufferAttrValid((BufferObject *)(self), name)))
1213 	return r;
1214 
1215     if (CheckBuffer((BufferObject *)(self)))
1216 	return NULL;
1217 
1218     r = BufferAttr((BufferObject *)(self), name);
1219     if (r || PyErr_Occurred())
1220 	return r;
1221     else
1222 	return Py_FindMethod(BufferMethods, self, name);
1223 }
1224 
1225 /******************/
1226 
1227     static PyInt
1228 BufferAssItem(PyObject *self, PyInt n, PyObject *val)
1229 {
1230     return RBAsItem((BufferObject *)(self), n, val, 1, -1, NULL);
1231 }
1232 
1233     static PyInt
1234 BufferAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
1235 {
1236     return RBAsSlice((BufferObject *)(self), lo, hi, val, 1, -1, NULL);
1237 }
1238 
1239 static PySequenceMethods RangeAsSeq = {
1240     (PyInquiry)		RangeLength,	      /* sq_length,    len(x)   */
1241     (binaryfunc)	0, /* RangeConcat, */ /* sq_concat,    x+y      */
1242     (PyIntArgFunc)	0, /* RangeRepeat, */ /* sq_repeat,    x*n      */
1243     (PyIntArgFunc)	RangeItem,	      /* sq_item,      x[i]     */
1244     (PyIntIntArgFunc)	RangeSlice,	      /* sq_slice,     x[i:j]   */
1245     (PyIntObjArgProc)	RangeAssItem,	      /* sq_ass_item,  x[i]=v   */
1246     (PyIntIntObjArgProc) RangeAssSlice,	      /* sq_ass_slice, x[i:j]=v */
1247     (objobjproc)	0,
1248 #if PY_MAJOR_VERSION >= 2
1249     (binaryfunc)	0,
1250     0,
1251 #endif
1252 };
1253 
1254 /* Line range object - Implementation
1255  */
1256 
1257     static PyObject *
1258 RangeGetattr(PyObject *self, char *name)
1259 {
1260     if (strcmp(name, "start") == 0)
1261 	return Py_BuildValue(Py_ssize_t_fmt, ((RangeObject *)(self))->start - 1);
1262     else if (strcmp(name, "end") == 0)
1263 	return Py_BuildValue(Py_ssize_t_fmt, ((RangeObject *)(self))->end - 1);
1264     else if (strcmp(name, "__members__") == 0)
1265 	return ObjectDir(NULL, RangeAttrs);
1266     else
1267 	return Py_FindMethod(RangeMethods, self, name);
1268 }
1269 
1270 /****************/
1271 
1272     static PyInt
1273 RangeAssItem(PyObject *self, PyInt n, PyObject *val)
1274 {
1275     return RBAsItem(((RangeObject *)(self))->buf, n, val,
1276 		     ((RangeObject *)(self))->start,
1277 		     ((RangeObject *)(self))->end,
1278 		     &((RangeObject *)(self))->end);
1279 }
1280 
1281     static PyInt
1282 RangeAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
1283 {
1284     return RBAsSlice(((RangeObject *)(self))->buf, lo, hi, val,
1285 		      ((RangeObject *)(self))->start,
1286 		      ((RangeObject *)(self))->end,
1287 		      &((RangeObject *)(self))->end);
1288 }
1289 
1290 /* TabPage object - Implementation
1291  */
1292 
1293     static PyObject *
1294 TabPageGetattr(PyObject *self, char *name)
1295 {
1296     PyObject *r;
1297 
1298     if ((r = TabPageAttrValid((TabPageObject *)(self), name)))
1299 	return r;
1300 
1301     if (CheckTabPage((TabPageObject *)(self)))
1302 	return NULL;
1303 
1304     r = TabPageAttr((TabPageObject *)(self), name);
1305     if (r || PyErr_Occurred())
1306 	return r;
1307     else
1308 	return Py_FindMethod(TabPageMethods, self, name);
1309 }
1310 
1311 /* Window object - Implementation
1312  */
1313 
1314     static PyObject *
1315 WindowGetattr(PyObject *self, char *name)
1316 {
1317     PyObject *r;
1318 
1319     if ((r = WindowAttrValid((WindowObject *)(self), name)))
1320 	return r;
1321 
1322     if (CheckWindow((WindowObject *)(self)))
1323 	return NULL;
1324 
1325     r = WindowAttr((WindowObject *)(self), name);
1326     if (r || PyErr_Occurred())
1327 	return r;
1328     else
1329 	return Py_FindMethod(WindowMethods, self, name);
1330 }
1331 
1332 /* Tab page list object - Definitions
1333  */
1334 
1335 static PySequenceMethods TabListAsSeq = {
1336     (PyInquiry)		TabListLength,	    /* sq_length,    len(x)   */
1337     (binaryfunc)	0,		    /* sq_concat,    x+y      */
1338     (PyIntArgFunc)	0,		    /* sq_repeat,    x*n      */
1339     (PyIntArgFunc)	TabListItem,	    /* sq_item,      x[i]     */
1340     (PyIntIntArgFunc)	0,		    /* sq_slice,     x[i:j]   */
1341     (PyIntObjArgProc)	0,		    /* sq_ass_item,  x[i]=v   */
1342     (PyIntIntObjArgProc) 0,		    /* sq_ass_slice, x[i:j]=v */
1343     (objobjproc)	0,
1344 #if PY_MAJOR_VERSION >= 2
1345     (binaryfunc)	0,
1346     0,
1347 #endif
1348 };
1349 
1350 /* Window list object - Definitions
1351  */
1352 
1353 static PySequenceMethods WinListAsSeq = {
1354     (PyInquiry)		WinListLength,	    /* sq_length,    len(x)   */
1355     (binaryfunc)	0,		    /* sq_concat,    x+y      */
1356     (PyIntArgFunc)	0,		    /* sq_repeat,    x*n      */
1357     (PyIntArgFunc)	WinListItem,	    /* sq_item,      x[i]     */
1358     (PyIntIntArgFunc)	0,		    /* sq_slice,     x[i:j]   */
1359     (PyIntObjArgProc)	0,		    /* sq_ass_item,  x[i]=v   */
1360     (PyIntIntObjArgProc) 0,		    /* sq_ass_slice, x[i:j]=v */
1361     (objobjproc)	0,
1362 #if PY_MAJOR_VERSION >= 2
1363     (binaryfunc)	0,
1364     0,
1365 #endif
1366 };
1367 
1368 /* External interface
1369  */
1370 
1371     void
1372 python_buffer_free(buf_T *buf)
1373 {
1374     if (BUF_PYTHON_REF(buf) != NULL)
1375     {
1376 	BufferObject *bp = BUF_PYTHON_REF(buf);
1377 	bp->buf = INVALID_BUFFER_VALUE;
1378 	BUF_PYTHON_REF(buf) = NULL;
1379     }
1380 }
1381 
1382 #if defined(FEAT_WINDOWS) || defined(PROTO)
1383     void
1384 python_window_free(win_T *win)
1385 {
1386     if (WIN_PYTHON_REF(win) != NULL)
1387     {
1388 	WindowObject *wp = WIN_PYTHON_REF(win);
1389 	wp->win = INVALID_WINDOW_VALUE;
1390 	WIN_PYTHON_REF(win) = NULL;
1391     }
1392 }
1393 
1394     void
1395 python_tabpage_free(tabpage_T *tab)
1396 {
1397     if (TAB_PYTHON_REF(tab) != NULL)
1398     {
1399 	TabPageObject *tp = TAB_PYTHON_REF(tab);
1400 	tp->tab = INVALID_TABPAGE_VALUE;
1401 	TAB_PYTHON_REF(tab) = NULL;
1402     }
1403 }
1404 #endif
1405 
1406     static int
1407 PythonMod_Init(void)
1408 {
1409     /* The special value is removed from sys.path in Python_Init(). */
1410     static char	*(argv[2]) = {"/must>not&exist/foo", NULL};
1411 
1412     if (init_types())
1413 	return -1;
1414 
1415     /* Set sys.argv[] to avoid a crash in warn(). */
1416     PySys_SetArgv(1, argv);
1417 
1418     vim_module = Py_InitModule4("vim", VimMethods, (char *)NULL,
1419 				(PyObject *)NULL, PYTHON_API_VERSION);
1420 
1421     if (populate_module(vim_module))
1422 	return -1;
1423 
1424     if (init_sys_path())
1425 	return -1;
1426 
1427     return 0;
1428 }
1429 
1430 /*************************************************************************
1431  * 4. Utility functions for handling the interface between Vim and Python.
1432  */
1433 
1434 /* Convert a Vim line into a Python string.
1435  * All internal newlines are replaced by null characters.
1436  *
1437  * On errors, the Python exception data is set, and NULL is returned.
1438  */
1439     static PyObject *
1440 LineToString(const char *str)
1441 {
1442     PyObject *result;
1443     PyInt len = strlen(str);
1444     char *p;
1445 
1446     /* Allocate an Python string object, with uninitialised contents. We
1447      * must do it this way, so that we can modify the string in place
1448      * later. See the Python source, Objects/stringobject.c for details.
1449      */
1450     result = PyString_FromStringAndSize(NULL, len);
1451     if (result == NULL)
1452 	return NULL;
1453 
1454     p = PyString_AsString(result);
1455 
1456     while (*str)
1457     {
1458 	if (*str == '\n')
1459 	    *p = '\0';
1460 	else
1461 	    *p = *str;
1462 
1463 	++p;
1464 	++str;
1465     }
1466 
1467     return result;
1468 }
1469 
1470     static PyObject *
1471 DictionaryGetattr(PyObject *self, char *name)
1472 {
1473     DictionaryObject	*this = ((DictionaryObject *) (self));
1474 
1475     if (strcmp(name, "locked") == 0)
1476 	return PyInt_FromLong(this->dict->dv_lock);
1477     else if (strcmp(name, "scope") == 0)
1478 	return PyInt_FromLong(this->dict->dv_scope);
1479     else if (strcmp(name, "__members__") == 0)
1480 	return ObjectDir(NULL, DictionaryAttrs);
1481 
1482     return Py_FindMethod(DictionaryMethods, self, name);
1483 }
1484 
1485     static PyObject *
1486 ListGetattr(PyObject *self, char *name)
1487 {
1488     if (strcmp(name, "locked") == 0)
1489 	return PyInt_FromLong(((ListObject *)(self))->list->lv_lock);
1490     else if (strcmp(name, "__members__") == 0)
1491 	return ObjectDir(NULL, ListAttrs);
1492 
1493     return Py_FindMethod(ListMethods, self, name);
1494 }
1495 
1496     static PyObject *
1497 FunctionGetattr(PyObject *self, char *name)
1498 {
1499     FunctionObject	*this = (FunctionObject *)(self);
1500 
1501     if (strcmp(name, "name") == 0)
1502 	return PyString_FromString((char *)(this->name));
1503     else if (strcmp(name, "__members__") == 0)
1504 	return ObjectDir(NULL, FunctionAttrs);
1505     else
1506 	return Py_FindMethod(FunctionMethods, self, name);
1507 }
1508 
1509     void
1510 do_pyeval (char_u *str, typval_T *rettv)
1511 {
1512     DoPyCommand((char *) str,
1513 	    (rangeinitializer) init_range_eval,
1514 	    (runner) run_eval,
1515 	    (void *) rettv);
1516     switch(rettv->v_type)
1517     {
1518 	case VAR_DICT: ++rettv->vval.v_dict->dv_refcount; break;
1519 	case VAR_LIST: ++rettv->vval.v_list->lv_refcount; break;
1520 	case VAR_FUNC: func_ref(rettv->vval.v_string);    break;
1521 	case VAR_UNKNOWN:
1522 	    rettv->v_type = VAR_NUMBER;
1523 	    rettv->vval.v_number = 0;
1524 	    break;
1525     }
1526 }
1527 
1528 /* Don't generate a prototype for the next function, it generates an error on
1529  * newer Python versions. */
1530 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */ && !defined(PROTO)
1531 
1532     char *
1533 Py_GetProgramName(void)
1534 {
1535     return "vim";
1536 }
1537 #endif /* Python 1.4 */
1538 
1539     void
1540 set_ref_in_python (int copyID)
1541 {
1542     set_ref_in_py(copyID);
1543 }
1544