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