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