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