1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
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.
10 * Python extensions by Paul Moore.
11 * Changes for Unix by David Leonard.
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.
24 /* Python.h defines _POSIX_THREADS itself (if needed) */
26 # undef _POSIX_THREADS
29 #if defined(_WIN32) && defined (HAVE_FCNTL_H)
38 # undef HAVE_STDARG_H /* Python's config.h defines it as well. */
41 #define PY_SSIZE_T_CLEAN
44 #if defined(MACOS) && !defined(MACOS_X_UNIX)
46 # include <CodeFragments.h>
48 #undef main /* Defined in python.h - aargh */
49 #undef HAVE_FCNTL_H /* Clash with os_win32.h */
51 #if !defined(FEAT_PYTHON) && defined(PROTO)
52 /* Use this to be able to generate prototypes without python being used. */
53 # define PyObject Py_ssize_t
54 # define PyThreadState Py_ssize_t
55 # define PyTypeObject Py_ssize_t
56 struct PyMethodDef
{ Py_ssize_t a
; };
57 # define PySequenceMethods Py_ssize_t
60 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02050000
61 # define PyInt Py_ssize_t
62 # define PyInquiry lenfunc
63 # define PyIntArgFunc ssizeargfunc
64 # define PyIntIntArgFunc ssizessizeargfunc
65 # define PyIntObjArgProc ssizeobjargproc
66 # define PyIntIntObjArgProc ssizessizeobjargproc
67 # define Py_ssize_t_fmt "n"
70 # define PyInquiry inquiry
71 # define PyIntArgFunc intargfunc
72 # define PyIntIntArgFunc intintargfunc
73 # define PyIntObjArgProc intobjargproc
74 # define PyIntIntObjArgProc intintobjargproc
75 # define Py_ssize_t_fmt "i"
79 #define single_input 256
80 #define file_input 257
81 #define eval_input 258
83 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x020300F0
84 /* Python 2.3: can invoke ":python" recursively. */
85 # define PY_CAN_RECURSE
88 #if defined(DYNAMIC_PYTHON) || defined(PROTO)
89 # ifndef DYNAMIC_PYTHON
90 # define HINSTANCE long_u /* for generating prototypes */
93 /* This makes if_python.c compile without warnings against Python 2.5
94 * on Win32 and Win64. */
95 #undef PyRun_SimpleString
97 #undef PyArg_ParseTuple
100 #undef Py_InitModule4_64
105 # define PyArg_Parse dll_PyArg_Parse
106 # define PyArg_ParseTuple dll_PyArg_ParseTuple
107 # define PyDict_SetItemString dll_PyDict_SetItemString
108 # define PyErr_BadArgument dll_PyErr_BadArgument
109 # define PyErr_Clear dll_PyErr_Clear
110 # define PyErr_NoMemory dll_PyErr_NoMemory
111 # define PyErr_Occurred dll_PyErr_Occurred
112 # define PyErr_SetNone dll_PyErr_SetNone
113 # define PyErr_SetString dll_PyErr_SetString
114 # define PyEval_InitThreads dll_PyEval_InitThreads
115 # define PyEval_RestoreThread dll_PyEval_RestoreThread
116 # define PyEval_SaveThread dll_PyEval_SaveThread
117 # ifdef PY_CAN_RECURSE
118 # define PyGILState_Ensure dll_PyGILState_Ensure
119 # define PyGILState_Release dll_PyGILState_Release
121 # define PyInt_AsLong dll_PyInt_AsLong
122 # define PyInt_FromLong dll_PyInt_FromLong
123 # define PyInt_Type (*dll_PyInt_Type)
124 # define PyList_GetItem dll_PyList_GetItem
125 # define PyList_Append dll_PyList_Append
126 # define PyList_New dll_PyList_New
127 # define PyList_SetItem dll_PyList_SetItem
128 # define PyList_Size dll_PyList_Size
129 # define PyList_Type (*dll_PyList_Type)
130 # define PyImport_ImportModule dll_PyImport_ImportModule
131 # define PyDict_New dll_PyDict_New
132 # define PyDict_GetItemString dll_PyDict_GetItemString
133 # define PyModule_GetDict dll_PyModule_GetDict
134 # define PyRun_SimpleString dll_PyRun_SimpleString
135 # define PyString_AsString dll_PyString_AsString
136 # define PyString_FromString dll_PyString_FromString
137 # define PyString_FromStringAndSize dll_PyString_FromStringAndSize
138 # define PyString_Size dll_PyString_Size
139 # define PyString_Type (*dll_PyString_Type)
140 # define PySys_SetObject dll_PySys_SetObject
141 # define PySys_SetArgv dll_PySys_SetArgv
142 # define PyType_Type (*dll_PyType_Type)
143 # define Py_BuildValue dll_Py_BuildValue
144 # define Py_FindMethod dll_Py_FindMethod
145 # define Py_InitModule4 dll_Py_InitModule4
146 # define Py_Initialize dll_Py_Initialize
147 # define Py_Finalize dll_Py_Finalize
148 # define Py_IsInitialized dll_Py_IsInitialized
149 # define _PyObject_New dll__PyObject_New
150 # define _Py_NoneStruct (*dll__Py_NoneStruct)
151 # define PyObject_Init dll__PyObject_Init
152 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000
153 # define PyType_IsSubtype dll_PyType_IsSubtype
155 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000
156 # define PyObject_Malloc dll_PyObject_Malloc
157 # define PyObject_Free dll_PyObject_Free
161 * Pointers for dynamic link
163 static int(*dll_PyArg_Parse
)(PyObject
*, char *, ...);
164 static int(*dll_PyArg_ParseTuple
)(PyObject
*, char *, ...);
165 static int(*dll_PyDict_SetItemString
)(PyObject
*dp
, char *key
, PyObject
*item
);
166 static int(*dll_PyErr_BadArgument
)(void);
167 static void(*dll_PyErr_Clear
)(void);
168 static PyObject
*(*dll_PyErr_NoMemory
)(void);
169 static PyObject
*(*dll_PyErr_Occurred
)(void);
170 static void(*dll_PyErr_SetNone
)(PyObject
*);
171 static void(*dll_PyErr_SetString
)(PyObject
*, const char *);
172 static void(*dll_PyEval_InitThreads
)(void);
173 static void(*dll_PyEval_RestoreThread
)(PyThreadState
*);
174 static PyThreadState
*(*dll_PyEval_SaveThread
)(void);
175 # ifdef PY_CAN_RECURSE
176 static PyGILState_STATE (*dll_PyGILState_Ensure
)(void);
177 static void (*dll_PyGILState_Release
)(PyGILState_STATE
);
179 static long(*dll_PyInt_AsLong
)(PyObject
*);
180 static PyObject
*(*dll_PyInt_FromLong
)(long);
181 static PyTypeObject
* dll_PyInt_Type
;
182 static PyObject
*(*dll_PyList_GetItem
)(PyObject
*, PyInt
);
183 static PyObject
*(*dll_PyList_Append
)(PyObject
*, PyObject
*);
184 static PyObject
*(*dll_PyList_New
)(PyInt size
);
185 static int(*dll_PyList_SetItem
)(PyObject
*, PyInt
, PyObject
*);
186 static PyInt(*dll_PyList_Size
)(PyObject
*);
187 static PyTypeObject
* dll_PyList_Type
;
188 static PyObject
*(*dll_PyImport_ImportModule
)(const char *);
189 static PyObject
*(*dll_PyDict_New
)(void);
190 static PyObject
*(*dll_PyDict_GetItemString
)(PyObject
*, const char *);
191 static PyObject
*(*dll_PyModule_GetDict
)(PyObject
*);
192 static int(*dll_PyRun_SimpleString
)(char *);
193 static char*(*dll_PyString_AsString
)(PyObject
*);
194 static PyObject
*(*dll_PyString_FromString
)(const char *);
195 static PyObject
*(*dll_PyString_FromStringAndSize
)(const char *, PyInt
);
196 static PyInt(*dll_PyString_Size
)(PyObject
*);
197 static PyTypeObject
* dll_PyString_Type
;
198 static int(*dll_PySys_SetObject
)(char *, PyObject
*);
199 static int(*dll_PySys_SetArgv
)(int, char **);
200 static PyTypeObject
* dll_PyType_Type
;
201 static PyObject
*(*dll_Py_BuildValue
)(char *, ...);
202 static PyObject
*(*dll_Py_FindMethod
)(struct PyMethodDef
[], PyObject
*, char *);
203 static PyObject
*(*dll_Py_InitModule4
)(char *, struct PyMethodDef
*, char *, PyObject
*, int);
204 static void(*dll_Py_Initialize
)(void);
205 static void(*dll_Py_Finalize
)(void);
206 static int(*dll_Py_IsInitialized
)(void);
207 static PyObject
*(*dll__PyObject_New
)(PyTypeObject
*, PyObject
*);
208 static PyObject
*(*dll__PyObject_Init
)(PyObject
*, PyTypeObject
*);
209 static PyObject
* dll__Py_NoneStruct
;
210 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000
211 static int (*dll_PyType_IsSubtype
)(PyTypeObject
*, PyTypeObject
*);
213 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000
214 static void* (*dll_PyObject_Malloc
)(size_t);
215 static void (*dll_PyObject_Free
)(void*);
218 static HINSTANCE hinstPython
= 0; /* Instance of python.dll */
220 /* Imported exception objects */
221 static PyObject
*imp_PyExc_AttributeError
;
222 static PyObject
*imp_PyExc_IndexError
;
223 static PyObject
*imp_PyExc_KeyboardInterrupt
;
224 static PyObject
*imp_PyExc_TypeError
;
225 static PyObject
*imp_PyExc_ValueError
;
227 # define PyExc_AttributeError imp_PyExc_AttributeError
228 # define PyExc_IndexError imp_PyExc_IndexError
229 # define PyExc_KeyboardInterrupt imp_PyExc_KeyboardInterrupt
230 # define PyExc_TypeError imp_PyExc_TypeError
231 # define PyExc_ValueError imp_PyExc_ValueError
234 * Table of name to function pointer of python.
236 # define PYTHON_PROC FARPROC
241 } python_funcname_table
[] =
243 {"PyArg_Parse", (PYTHON_PROC
*)&dll_PyArg_Parse
},
244 {"PyArg_ParseTuple", (PYTHON_PROC
*)&dll_PyArg_ParseTuple
},
245 {"PyDict_SetItemString", (PYTHON_PROC
*)&dll_PyDict_SetItemString
},
246 {"PyErr_BadArgument", (PYTHON_PROC
*)&dll_PyErr_BadArgument
},
247 {"PyErr_Clear", (PYTHON_PROC
*)&dll_PyErr_Clear
},
248 {"PyErr_NoMemory", (PYTHON_PROC
*)&dll_PyErr_NoMemory
},
249 {"PyErr_Occurred", (PYTHON_PROC
*)&dll_PyErr_Occurred
},
250 {"PyErr_SetNone", (PYTHON_PROC
*)&dll_PyErr_SetNone
},
251 {"PyErr_SetString", (PYTHON_PROC
*)&dll_PyErr_SetString
},
252 {"PyEval_InitThreads", (PYTHON_PROC
*)&dll_PyEval_InitThreads
},
253 {"PyEval_RestoreThread", (PYTHON_PROC
*)&dll_PyEval_RestoreThread
},
254 {"PyEval_SaveThread", (PYTHON_PROC
*)&dll_PyEval_SaveThread
},
255 # ifdef PY_CAN_RECURSE
256 {"PyGILState_Ensure", (PYTHON_PROC
*)&dll_PyGILState_Ensure
},
257 {"PyGILState_Release", (PYTHON_PROC
*)&dll_PyGILState_Release
},
259 {"PyInt_AsLong", (PYTHON_PROC
*)&dll_PyInt_AsLong
},
260 {"PyInt_FromLong", (PYTHON_PROC
*)&dll_PyInt_FromLong
},
261 {"PyInt_Type", (PYTHON_PROC
*)&dll_PyInt_Type
},
262 {"PyList_GetItem", (PYTHON_PROC
*)&dll_PyList_GetItem
},
263 {"PyList_Append", (PYTHON_PROC
*)&dll_PyList_Append
},
264 {"PyList_New", (PYTHON_PROC
*)&dll_PyList_New
},
265 {"PyList_SetItem", (PYTHON_PROC
*)&dll_PyList_SetItem
},
266 {"PyList_Size", (PYTHON_PROC
*)&dll_PyList_Size
},
267 {"PyList_Type", (PYTHON_PROC
*)&dll_PyList_Type
},
268 {"PyImport_ImportModule", (PYTHON_PROC
*)&dll_PyImport_ImportModule
},
269 {"PyDict_GetItemString", (PYTHON_PROC
*)&dll_PyDict_GetItemString
},
270 {"PyDict_New", (PYTHON_PROC
*)&dll_PyDict_New
},
271 {"PyModule_GetDict", (PYTHON_PROC
*)&dll_PyModule_GetDict
},
272 {"PyRun_SimpleString", (PYTHON_PROC
*)&dll_PyRun_SimpleString
},
273 {"PyString_AsString", (PYTHON_PROC
*)&dll_PyString_AsString
},
274 {"PyString_FromString", (PYTHON_PROC
*)&dll_PyString_FromString
},
275 {"PyString_FromStringAndSize", (PYTHON_PROC
*)&dll_PyString_FromStringAndSize
},
276 {"PyString_Size", (PYTHON_PROC
*)&dll_PyString_Size
},
277 {"PyString_Type", (PYTHON_PROC
*)&dll_PyString_Type
},
278 {"PySys_SetObject", (PYTHON_PROC
*)&dll_PySys_SetObject
},
279 {"PySys_SetArgv", (PYTHON_PROC
*)&dll_PySys_SetArgv
},
280 {"PyType_Type", (PYTHON_PROC
*)&dll_PyType_Type
},
281 {"Py_BuildValue", (PYTHON_PROC
*)&dll_Py_BuildValue
},
282 {"Py_FindMethod", (PYTHON_PROC
*)&dll_Py_FindMethod
},
283 # if (PY_VERSION_HEX >= 0x02050000) && SIZEOF_SIZE_T != SIZEOF_INT
284 {"Py_InitModule4_64", (PYTHON_PROC
*)&dll_Py_InitModule4
},
286 {"Py_InitModule4", (PYTHON_PROC
*)&dll_Py_InitModule4
},
288 {"Py_Initialize", (PYTHON_PROC
*)&dll_Py_Initialize
},
289 {"Py_Finalize", (PYTHON_PROC
*)&dll_Py_Finalize
},
290 {"Py_IsInitialized", (PYTHON_PROC
*)&dll_Py_IsInitialized
},
291 {"_PyObject_New", (PYTHON_PROC
*)&dll__PyObject_New
},
292 {"PyObject_Init", (PYTHON_PROC
*)&dll__PyObject_Init
},
293 {"_Py_NoneStruct", (PYTHON_PROC
*)&dll__Py_NoneStruct
},
294 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02020000
295 {"PyType_IsSubtype", (PYTHON_PROC
*)&dll_PyType_IsSubtype
},
297 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000
298 {"PyObject_Malloc", (PYTHON_PROC
*)&dll_PyObject_Malloc
},
299 {"PyObject_Free", (PYTHON_PROC
*)&dll_PyObject_Free
},
308 end_dynamic_python(void)
312 FreeLibrary(hinstPython
);
318 * Load library and get all pointers.
319 * Parameter 'libname' provides name of DLL.
323 python_runtime_link_init(char *libname
, int verbose
)
329 hinstPython
= LoadLibrary(libname
);
333 EMSG2(_(e_loadlib
), libname
);
337 for (i
= 0; python_funcname_table
[i
].ptr
; ++i
)
339 if ((*python_funcname_table
[i
].ptr
= GetProcAddress(hinstPython
,
340 python_funcname_table
[i
].name
)) == NULL
)
342 FreeLibrary(hinstPython
);
345 EMSG2(_(e_loadfunc
), python_funcname_table
[i
].name
);
353 * If python is enabled (there is installed python on Windows system) return
357 python_enabled(int verbose
)
359 return python_runtime_link_init(DYNAMIC_PYTHON_DLL
, verbose
) == OK
;
362 /* Load the standard Python exceptions - don't import the symbols from the
363 * DLL, as this can cause errors (importing data symbols is not reliable).
365 static void get_exceptions
__ARGS((void));
370 PyObject
*exmod
= PyImport_ImportModule("exceptions");
371 PyObject
*exdict
= PyModule_GetDict(exmod
);
372 imp_PyExc_AttributeError
= PyDict_GetItemString(exdict
, "AttributeError");
373 imp_PyExc_IndexError
= PyDict_GetItemString(exdict
, "IndexError");
374 imp_PyExc_KeyboardInterrupt
= PyDict_GetItemString(exdict
, "KeyboardInterrupt");
375 imp_PyExc_TypeError
= PyDict_GetItemString(exdict
, "TypeError");
376 imp_PyExc_ValueError
= PyDict_GetItemString(exdict
, "ValueError");
377 Py_XINCREF(imp_PyExc_AttributeError
);
378 Py_XINCREF(imp_PyExc_IndexError
);
379 Py_XINCREF(imp_PyExc_KeyboardInterrupt
);
380 Py_XINCREF(imp_PyExc_TypeError
);
381 Py_XINCREF(imp_PyExc_ValueError
);
384 #endif /* DYNAMIC_PYTHON */
386 /******************************************************
387 * Internal function prototypes.
390 static void DoPythonCommand(exarg_T
*, const char *);
391 static PyInt RangeStart
;
392 static PyInt RangeEnd
;
394 static void PythonIO_Flush(void);
395 static int PythonIO_Init(void);
396 static int PythonMod_Init(void);
398 /* Utility functions for the vim/python interface
399 * ----------------------------------------------
401 static PyObject
*GetBufferLine(buf_T
*, PyInt
);
402 static PyObject
*GetBufferLineList(buf_T
*, PyInt
, PyInt
);
404 static int SetBufferLine(buf_T
*, PyInt
, PyObject
*, PyInt
*);
405 static int SetBufferLineList(buf_T
*, PyInt
, PyInt
, PyObject
*, PyInt
*);
406 static int InsertBufferLines(buf_T
*, PyInt
, PyObject
*, PyInt
*);
408 static PyObject
*LineToString(const char *);
409 static char *StringToLine(PyObject
*);
411 static int VimErrorCheck(void);
413 #define PyErr_SetVim(str) PyErr_SetString(VimError, str)
415 /******************************************************
416 * 1. Python interpreter main program.
419 static int initialised
= 0;
421 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */
422 typedef PyObject PyThreadState
;
425 #ifdef PY_CAN_RECURSE
426 static PyGILState_STATE pygilstate
= PyGILState_UNLOCKED
;
428 static PyThreadState
*saved_python_thread
= NULL
;
432 * Suspend a thread of the Python interpreter, other threads are allowed to
436 Python_SaveThread(void)
438 #ifdef PY_CAN_RECURSE
439 PyGILState_Release(pygilstate
);
441 saved_python_thread
= PyEval_SaveThread();
446 * Restore a thread of the Python interpreter, waits for other threads to
450 Python_RestoreThread(void)
452 #ifdef PY_CAN_RECURSE
453 pygilstate
= PyGILState_Ensure();
455 PyEval_RestoreThread(saved_python_thread
);
456 saved_python_thread
= NULL
;
461 * obtain a lock on the Vim data structures
463 static void Python_Lock_Vim(void)
468 * release a lock on the Vim data structures
470 static void Python_Release_Vim(void)
477 static int recurse
= 0;
479 /* If a crash occurs while doing this, don't try again. */
485 #ifdef DYNAMIC_PYTHON
486 if (hinstPython
&& Py_IsInitialized())
488 Python_RestoreThread(); /* enter python */
491 end_dynamic_python();
493 if (Py_IsInitialized())
495 Python_RestoreThread(); /* enter python */
508 #ifdef DYNAMIC_PYTHON
509 if (!python_enabled(TRUE
))
511 EMSG(_("E263: Sorry, this command is disabled, the Python library could not be loaded."));
516 #if !defined(MACOS) || defined(MACOS_X_UNIX)
521 /* initialise threads */
522 PyEval_InitThreads();
524 #ifdef DYNAMIC_PYTHON
531 if (PythonMod_Init())
534 /* Remove the element from sys.path that was added because of our
535 * argv[0] value in PythonMod_Init(). Previously we used an empty
536 * string, but dependinding on the OS we then get an empty entry or
537 * the current directory in sys.path. */
538 PyRun_SimpleString("import sys; sys.path = filter(lambda x: x != '/must>not&exist', sys.path)");
540 /* the first python thread is vim's, release the lock */
549 /* We call PythonIO_Flush() here to print any Python errors.
550 * This is OK, as it is possible to call this function even
551 * if PythonIO_Init() has not completed successfully (it will
552 * not do anything in this case).
562 DoPythonCommand(exarg_T
*eap
, const char *cmd
)
564 #ifndef PY_CAN_RECURSE
565 static int recursive
= 0;
567 #if defined(MACOS) && !defined(MACOS_X_UNIX)
570 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
574 #ifndef PY_CAN_RECURSE
577 EMSG(_("E659: Cannot invoke Python recursively"));
583 #if defined(MACOS) && !defined(MACOS_X_UNIX)
585 /* Check if the Python library is available */
586 if ((Ptr
)PyMac_Initialize
== (Ptr
)kUnresolvedCFragSymbolAddress
)
592 RangeStart
= eap
->line1
;
593 RangeEnd
= eap
->line2
;
594 Python_Release_Vim(); /* leave vim */
596 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
597 /* Python only works properly when the LC_NUMERIC locale is "C". */
598 saved_locale
= setlocale(LC_NUMERIC
, NULL
);
599 if (saved_locale
== NULL
|| STRCMP(saved_locale
, "C") == 0)
603 /* Need to make a copy, value may change when setting new locale. */
604 saved_locale
= (char *)vim_strsave((char_u
*)saved_locale
);
605 (void)setlocale(LC_NUMERIC
, "C");
609 Python_RestoreThread(); /* enter python */
611 PyRun_SimpleString((char *)(cmd
));
613 Python_SaveThread(); /* leave python */
615 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
616 if (saved_locale
!= NULL
)
618 (void)setlocale(LC_NUMERIC
, saved_locale
);
619 vim_free(saved_locale
);
623 Python_Lock_Vim(); /* enter vim */
625 #if defined(MACOS) && !defined(MACOS_X_UNIX)
630 #ifndef PY_CAN_RECURSE
633 return; /* keeps lint happy */
640 ex_python(exarg_T
*eap
)
644 script
= script_get(eap
, eap
->arg
);
648 DoPythonCommand(eap
, (char *)eap
->arg
);
650 DoPythonCommand(eap
, (char *)script
);
655 #define BUFFER_SIZE 1024
661 ex_pyfile(exarg_T
*eap
)
663 static char buffer
[BUFFER_SIZE
];
664 const char *file
= (char *)eap
->arg
;
667 /* Have to do it like this. PyRun_SimpleFile requires you to pass a
668 * stdio file pointer, but Vim and the Python DLL are compiled with
669 * different options under Windows, meaning that stdio pointers aren't
670 * compatible between the two. Yuk.
672 * Put the string "execfile('file')" into buffer. But, we need to
673 * escape any backslashes or single quotes in the file name, so that
674 * Python won't mangle the file name.
676 strcpy(buffer
, "execfile('");
677 p
= buffer
+ 10; /* size of "execfile('" */
679 while (*file
&& p
< buffer
+ (BUFFER_SIZE
- 3))
681 if (*file
== '\\' || *file
== '\'')
686 /* If we didn't finish the file name, we hit a buffer overflow */
690 /* Put in the terminating "')" and a null */
695 /* Execute the file */
696 DoPythonCommand(eap
, buffer
);
699 /******************************************************
700 * 2. Python output stream: writes output via [e]msg().
703 /* Implementation functions
706 static PyObject
*OutputGetattr(PyObject
*, char *);
707 static int OutputSetattr(PyObject
*, char *, PyObject
*);
709 static PyObject
*OutputWrite(PyObject
*, PyObject
*);
710 static PyObject
*OutputWritelines(PyObject
*, PyObject
*);
712 typedef void (*writefn
)(char_u
*);
713 static void writer(writefn fn
, char_u
*str
, PyInt n
);
715 /* Output object definition
725 static struct PyMethodDef OutputMethods
[] = {
726 /* name, function, calling, documentation */
727 {"write", OutputWrite
, 1, "" },
728 {"writelines", OutputWritelines
, 1, "" },
729 { NULL
, NULL
, 0, NULL
}
732 static PyTypeObject OutputType
= {
733 PyObject_HEAD_INIT(0)
736 sizeof(OutputObject
),
741 (getattrfunc
) OutputGetattr
,
742 (setattrfunc
) OutputSetattr
,
758 OutputGetattr(PyObject
*self
, char *name
)
760 if (strcmp(name
, "softspace") == 0)
761 return PyInt_FromLong(((OutputObject
*)(self
))->softspace
);
763 return Py_FindMethod(OutputMethods
, self
, name
);
767 OutputSetattr(PyObject
*self
, char *name
, PyObject
*val
)
770 PyErr_SetString(PyExc_AttributeError
, _("can't delete OutputObject attributes"));
774 if (strcmp(name
, "softspace") == 0)
776 if (!PyInt_Check(val
)) {
777 PyErr_SetString(PyExc_TypeError
, _("softspace must be an integer"));
781 ((OutputObject
*)(self
))->softspace
= PyInt_AsLong(val
);
785 PyErr_SetString(PyExc_AttributeError
, _("invalid attribute"));
792 OutputWrite(PyObject
*self
, PyObject
*args
)
796 int error
= ((OutputObject
*)(self
))->error
;
798 if (!PyArg_ParseTuple(args
, "s#", &str
, &len
))
801 Py_BEGIN_ALLOW_THREADS
803 writer((writefn
)(error
? emsg
: msg
), (char_u
*)str
, len
);
804 Python_Release_Vim();
812 OutputWritelines(PyObject
*self
, PyObject
*args
)
817 int error
= ((OutputObject
*)(self
))->error
;
819 if (!PyArg_ParseTuple(args
, "O", &list
))
823 if (!PyList_Check(list
)) {
824 PyErr_SetString(PyExc_TypeError
, _("writelines() requires list of strings"));
829 n
= PyList_Size(list
);
831 for (i
= 0; i
< n
; ++i
)
833 PyObject
*line
= PyList_GetItem(list
, i
);
837 if (!PyArg_Parse(line
, "s#", &str
, &len
)) {
838 PyErr_SetString(PyExc_TypeError
, _("writelines() requires list of strings"));
843 Py_BEGIN_ALLOW_THREADS
845 writer((writefn
)(error
? emsg
: msg
), (char_u
*)str
, len
);
846 Python_Release_Vim();
855 /* Output buffer management
858 static char_u
*buffer
= NULL
;
859 static PyInt buffer_len
= 0;
860 static PyInt buffer_size
= 0;
862 static writefn old_fn
= NULL
;
865 buffer_ensure(PyInt n
)
873 new_size
= buffer_size
;
877 if (new_size
!= buffer_size
)
879 new_buffer
= alloc((unsigned)new_size
);
880 if (new_buffer
== NULL
)
885 memcpy(new_buffer
, buffer
, buffer_len
);
890 buffer_size
= new_size
;
897 if (old_fn
&& buffer_len
)
899 buffer
[buffer_len
] = 0;
907 writer(writefn fn
, char_u
*str
, PyInt n
)
911 if (fn
!= old_fn
&& old_fn
!= NULL
)
916 while (n
> 0 && (ptr
= memchr(str
, '\n', n
)) != NULL
)
918 PyInt len
= ptr
- str
;
920 buffer_ensure(buffer_len
+ len
+ 1);
922 memcpy(buffer
+ buffer_len
, str
, len
);
924 buffer
[buffer_len
] = 0;
931 /* Put the remaining text into the buffer for later printing */
932 buffer_ensure(buffer_len
+ n
+ 1);
933 memcpy(buffer
+ buffer_len
, str
, n
);
939 static OutputObject Output
=
941 PyObject_HEAD_INIT(&OutputType
)
946 static OutputObject Error
=
948 PyObject_HEAD_INIT(&OutputType
)
957 OutputType
.ob_type
= &PyType_Type
;
959 PySys_SetObject("stdout", (PyObject
*)(void *)&Output
);
960 PySys_SetObject("stderr", (PyObject
*)(void *)&Error
);
962 if (PyErr_Occurred())
964 EMSG(_("E264: Python: Error initialising I/O objects"));
971 /******************************************************
972 * 3. Implementation of the Vim module for Python
975 /* Vim module - Implementation functions
976 * -------------------------------------
979 static PyObject
*VimError
;
981 static PyObject
*VimCommand(PyObject
*, PyObject
*);
982 static PyObject
*VimEval(PyObject
*, PyObject
*);
984 /* Window type - Implementation functions
985 * --------------------------------------
995 #define INVALID_WINDOW_VALUE ((win_T *)(-1))
997 #define WindowType_Check(obj) ((obj)->ob_type == &WindowType)
999 static PyObject
*WindowNew(win_T
*);
1001 static void WindowDestructor(PyObject
*);
1002 static PyObject
*WindowGetattr(PyObject
*, char *);
1003 static int WindowSetattr(PyObject
*, char *, PyObject
*);
1004 static PyObject
*WindowRepr(PyObject
*);
1006 /* Buffer type - Implementation functions
1007 * --------------------------------------
1017 #define INVALID_BUFFER_VALUE ((buf_T *)(-1))
1019 #define BufferType_Check(obj) ((obj)->ob_type == &BufferType)
1021 static PyObject
*BufferNew (buf_T
*);
1023 static void BufferDestructor(PyObject
*);
1024 static PyObject
*BufferGetattr(PyObject
*, char *);
1025 static PyObject
*BufferRepr(PyObject
*);
1027 static PyInt
BufferLength(PyObject
*);
1028 static PyObject
*BufferItem(PyObject
*, PyInt
);
1029 static PyObject
*BufferSlice(PyObject
*, PyInt
, PyInt
);
1030 static PyInt
BufferAssItem(PyObject
*, PyInt
, PyObject
*);
1031 static PyInt
BufferAssSlice(PyObject
*, PyInt
, PyInt
, PyObject
*);
1033 static PyObject
*BufferAppend(PyObject
*, PyObject
*);
1034 static PyObject
*BufferMark(PyObject
*, PyObject
*);
1035 static PyObject
*BufferRange(PyObject
*, PyObject
*);
1037 /* Line range type - Implementation functions
1038 * --------------------------------------
1050 #define RangeType_Check(obj) ((obj)->ob_type == &RangeType)
1052 static PyObject
*RangeNew(buf_T
*, PyInt
, PyInt
);
1054 static void RangeDestructor(PyObject
*);
1055 static PyObject
*RangeGetattr(PyObject
*, char *);
1056 static PyObject
*RangeRepr(PyObject
*);
1058 static PyInt
RangeLength(PyObject
*);
1059 static PyObject
*RangeItem(PyObject
*, PyInt
);
1060 static PyObject
*RangeSlice(PyObject
*, PyInt
, PyInt
);
1061 static PyInt
RangeAssItem(PyObject
*, PyInt
, PyObject
*);
1062 static PyInt
RangeAssSlice(PyObject
*, PyInt
, PyInt
, PyObject
*);
1064 static PyObject
*RangeAppend(PyObject
*, PyObject
*);
1066 /* Window list type - Implementation functions
1067 * -------------------------------------------
1070 static PyInt
WinListLength(PyObject
*);
1071 static PyObject
*WinListItem(PyObject
*, PyInt
);
1073 /* Buffer list type - Implementation functions
1074 * -------------------------------------------
1077 static PyInt
BufListLength(PyObject
*);
1078 static PyObject
*BufListItem(PyObject
*, PyInt
);
1080 /* Current objects type - Implementation functions
1081 * -----------------------------------------------
1084 static PyObject
*CurrentGetattr(PyObject
*, char *);
1085 static int CurrentSetattr(PyObject
*, char *, PyObject
*);
1087 /* Vim module - Definitions
1090 static struct PyMethodDef VimMethods
[] = {
1091 /* name, function, calling, documentation */
1092 {"command", VimCommand
, 1, "Execute a Vim ex-mode command" },
1093 {"eval", VimEval
, 1, "Evaluate an expression using Vim evaluator" },
1094 { NULL
, NULL
, 0, NULL
}
1097 /* Vim module - Implementation
1101 VimCommand(PyObject
*self
, PyObject
*args
)
1106 if (!PyArg_ParseTuple(args
, "s", &cmd
))
1111 Py_BEGIN_ALLOW_THREADS
1114 do_cmdline_cmd((char_u
*)cmd
);
1115 update_screen(VALID
);
1117 Python_Release_Vim();
1118 Py_END_ALLOW_THREADS
1120 if (VimErrorCheck())
1131 * Function to translate a typval_T into a PyObject; this will recursively
1132 * translate lists/dictionaries into their Python equivalents.
1134 * The depth parameter is to avoid infinite recursion, set it to 1 when
1135 * you call VimToPython.
1138 VimToPython(typval_T
*our_tv
, int depth
, PyObject
*lookupDict
)
1142 char ptrBuf
[NUMBUFLEN
];
1144 /* Avoid infinite recursion */
1152 /* Check if we run into a recursive loop. The item must be in lookupDict
1153 * then and we can use it again. */
1154 sprintf(ptrBuf
, PRINTF_DECIMAL_LONG_U
, (long_u
)our_tv
);
1155 result
= PyDict_GetItemString(lookupDict
, ptrBuf
);
1158 else if (our_tv
->v_type
== VAR_STRING
)
1160 result
= Py_BuildValue("s", our_tv
->vval
.v_string
);
1161 PyDict_SetItemString(lookupDict
, ptrBuf
, result
);
1163 else if (our_tv
->v_type
== VAR_NUMBER
)
1165 char buf
[NUMBUFLEN
];
1167 /* For backwards compatibility numbers are stored as strings. */
1168 sprintf(buf
, "%ld", (long)our_tv
->vval
.v_number
);
1169 result
= Py_BuildValue("s", buf
);
1170 PyDict_SetItemString(lookupDict
, ptrBuf
, result
);
1173 else if (our_tv
->v_type
== VAR_FLOAT
)
1175 char buf
[NUMBUFLEN
];
1177 sprintf(buf
, "%f", our_tv
->vval
.v_float
);
1178 result
= Py_BuildValue("s", buf
);
1179 PyDict_SetItemString(lookupDict
, ptrBuf
, result
);
1182 else if (our_tv
->v_type
== VAR_LIST
)
1184 list_T
*list
= our_tv
->vval
.v_list
;
1187 result
= PyList_New(0);
1188 PyDict_SetItemString(lookupDict
, ptrBuf
, result
);
1192 for (curr
= list
->lv_first
; curr
!= NULL
; curr
= curr
->li_next
)
1194 newObj
= VimToPython(&curr
->li_tv
, depth
+ 1, lookupDict
);
1195 PyList_Append(result
, newObj
);
1200 else if (our_tv
->v_type
== VAR_DICT
)
1202 result
= PyDict_New();
1203 PyDict_SetItemString(lookupDict
, ptrBuf
, result
);
1205 if (our_tv
->vval
.v_dict
!= NULL
)
1207 hashtab_T
*ht
= &our_tv
->vval
.v_dict
->dv_hashtab
;
1208 long_u todo
= ht
->ht_used
;
1212 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
1214 if (!HASHITEM_EMPTY(hi
))
1218 di
= dict_lookup(hi
);
1219 newObj
= VimToPython(&di
->di_tv
, depth
+ 1, lookupDict
);
1220 PyDict_SetItemString(result
, (char *)hi
->hi_key
, newObj
);
1238 VimEval(PyObject
*self
, PyObject
*args
)
1244 PyObject
*lookup_dict
;
1246 if (!PyArg_ParseTuple(args
, "s", &expr
))
1249 Py_BEGIN_ALLOW_THREADS
1251 our_tv
= eval_expr((char_u
*)expr
, NULL
);
1253 Python_Release_Vim();
1254 Py_END_ALLOW_THREADS
1258 PyErr_SetVim(_("invalid expression"));
1262 /* Convert the Vim type into a Python type. Create a dictionary that's
1263 * used to check for recursive loops. */
1264 lookup_dict
= PyDict_New();
1265 result
= VimToPython(our_tv
, 1, lookup_dict
);
1266 Py_DECREF(lookup_dict
);
1269 Py_BEGIN_ALLOW_THREADS
1272 Python_Release_Vim();
1273 Py_END_ALLOW_THREADS
1277 PyErr_SetVim(_("expressions disabled at compile time"));
1282 /* Common routines for buffers and line ranges
1283 * -------------------------------------------
1286 CheckBuffer(BufferObject
*this)
1288 if (this->buf
== INVALID_BUFFER_VALUE
)
1290 PyErr_SetVim(_("attempt to refer to deleted buffer"));
1298 RBItem(BufferObject
*self
, PyInt n
, PyInt start
, PyInt end
)
1300 if (CheckBuffer(self
))
1303 if (n
< 0 || n
> end
- start
)
1305 PyErr_SetString(PyExc_IndexError
, _("line number out of range"));
1309 return GetBufferLine(self
->buf
, n
+start
);
1313 RBSlice(BufferObject
*self
, PyInt lo
, PyInt hi
, PyInt start
, PyInt end
)
1317 if (CheckBuffer(self
))
1320 size
= end
- start
+ 1;
1333 return GetBufferLineList(self
->buf
, lo
+start
, hi
+start
);
1337 RBAssItem(BufferObject
*self
, PyInt n
, PyObject
*val
, PyInt start
, PyInt end
, PyInt
*new_end
)
1341 if (CheckBuffer(self
))
1344 if (n
< 0 || n
> end
- start
)
1346 PyErr_SetString(PyExc_IndexError
, _("line number out of range"));
1350 if (SetBufferLine(self
->buf
, n
+start
, val
, &len_change
) == FAIL
)
1354 *new_end
= end
+ len_change
;
1360 RBAssSlice(BufferObject
*self
, PyInt lo
, PyInt hi
, PyObject
*val
, PyInt start
, PyInt end
, PyInt
*new_end
)
1365 /* Self must be a valid buffer */
1366 if (CheckBuffer(self
))
1369 /* Sort out the slice range */
1370 size
= end
- start
+ 1;
1383 if (SetBufferLineList(self
->buf
, lo
+start
, hi
+start
, val
, &len_change
) == FAIL
)
1387 *new_end
= end
+ len_change
;
1393 RBAppend(BufferObject
*self
, PyObject
*args
, PyInt start
, PyInt end
, PyInt
*new_end
)
1400 if (CheckBuffer(self
))
1403 max
= n
= end
- start
+ 1;
1405 if (!PyArg_ParseTuple(args
, "O|" Py_ssize_t_fmt
, &lines
, &n
))
1408 if (n
< 0 || n
> max
)
1410 PyErr_SetString(PyExc_ValueError
, _("line number out of range"));
1414 if (InsertBufferLines(self
->buf
, n
+ start
- 1, lines
, &len_change
) == FAIL
)
1418 *new_end
= end
+ len_change
;
1425 /* Buffer object - Definitions
1428 static struct PyMethodDef BufferMethods
[] = {
1429 /* name, function, calling, documentation */
1430 {"append", BufferAppend
, 1, "Append data to Vim buffer" },
1431 {"mark", BufferMark
, 1, "Return (row,col) representing position of named mark" },
1432 {"range", BufferRange
, 1, "Return a range object which represents the part of the given buffer between line numbers s and e" },
1433 { NULL
, NULL
, 0, NULL
}
1436 static PySequenceMethods BufferAsSeq
= {
1437 (PyInquiry
) BufferLength
, /* sq_length, len(x) */
1438 (binaryfunc
) 0, /* BufferConcat, */ /* sq_concat, x+y */
1439 (PyIntArgFunc
) 0, /* BufferRepeat, */ /* sq_repeat, x*n */
1440 (PyIntArgFunc
) BufferItem
, /* sq_item, x[i] */
1441 (PyIntIntArgFunc
) BufferSlice
, /* sq_slice, x[i:j] */
1442 (PyIntObjArgProc
) BufferAssItem
, /* sq_ass_item, x[i]=v */
1443 (PyIntIntObjArgProc
) BufferAssSlice
, /* sq_ass_slice, x[i:j]=v */
1446 static PyTypeObject BufferType
= {
1447 PyObject_HEAD_INIT(0)
1450 sizeof(BufferObject
),
1453 (destructor
) BufferDestructor
, /* tp_dealloc, refcount==0 */
1454 (printfunc
) 0, /* tp_print, print x */
1455 (getattrfunc
) BufferGetattr
, /* tp_getattr, x.attr */
1456 (setattrfunc
) 0, /* tp_setattr, x.attr=v */
1457 (cmpfunc
) 0, /* tp_compare, x>y */
1458 (reprfunc
) BufferRepr
, /* tp_repr, `x`, print x */
1461 &BufferAsSeq
, /* as sequence */
1464 (hashfunc
) 0, /* tp_hash, dict(x) */
1465 (ternaryfunc
) 0, /* tp_call, x() */
1466 (reprfunc
) 0, /* tp_str, str(x) */
1469 /* Buffer object - Implementation
1473 BufferNew(buf_T
*buf
)
1475 /* We need to handle deletion of buffers underneath us.
1476 * If we add a "b_python_ref" field to the buf_T structure,
1477 * then we can get at it in buf_freeall() in vim. We then
1478 * need to create only ONE Python object per buffer - if
1479 * we try to create a second, just INCREF the existing one
1480 * and return it. The (single) Python object referring to
1481 * the buffer is stored in "b_python_ref".
1482 * Question: what to do on a buf_freeall(). We'll probably
1483 * have to either delete the Python object (DECREF it to
1484 * zero - a bad idea, as it leaves dangling refs!) or
1485 * set the buf_T * value to an invalid value (-1?), which
1486 * means we need checks in all access functions... Bah.
1491 if (buf
->b_python_ref
!= NULL
)
1493 self
= buf
->b_python_ref
;
1498 self
= PyObject_NEW(BufferObject
, &BufferType
);
1502 buf
->b_python_ref
= self
;
1505 return (PyObject
*)(self
);
1509 BufferDestructor(PyObject
*self
)
1511 BufferObject
*this = (BufferObject
*)(self
);
1513 if (this->buf
&& this->buf
!= INVALID_BUFFER_VALUE
)
1514 this->buf
->b_python_ref
= NULL
;
1520 BufferGetattr(PyObject
*self
, char *name
)
1522 BufferObject
*this = (BufferObject
*)(self
);
1524 if (CheckBuffer(this))
1527 if (strcmp(name
, "name") == 0)
1528 return Py_BuildValue("s", this->buf
->b_ffname
);
1529 else if (strcmp(name
, "number") == 0)
1530 return Py_BuildValue(Py_ssize_t_fmt
, this->buf
->b_fnum
);
1531 else if (strcmp(name
,"__members__") == 0)
1532 return Py_BuildValue("[ss]", "name", "number");
1534 return Py_FindMethod(BufferMethods
, self
, name
);
1538 BufferRepr(PyObject
*self
)
1540 static char repr
[100];
1541 BufferObject
*this = (BufferObject
*)(self
);
1543 if (this->buf
== INVALID_BUFFER_VALUE
)
1545 vim_snprintf(repr
, 100, _("<buffer object (deleted) at %p>"), (self
));
1546 return PyString_FromString(repr
);
1550 char *name
= (char *)this->buf
->b_fname
;
1558 name
= name
+ (35 - len
);
1560 vim_snprintf(repr
, 100, "<buffer %s%s>", len
> 35 ? "..." : "", name
);
1562 return PyString_FromString(repr
);
1566 /******************/
1569 BufferLength(PyObject
*self
)
1571 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
1572 if (CheckBuffer((BufferObject
*)(self
)))
1573 return -1; /* ??? */
1575 return (((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
);
1579 BufferItem(PyObject
*self
, PyInt n
)
1581 return RBItem((BufferObject
*)(self
), n
, 1,
1582 (int)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
);
1586 BufferSlice(PyObject
*self
, PyInt lo
, PyInt hi
)
1588 return RBSlice((BufferObject
*)(self
), lo
, hi
, 1,
1589 (int)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
);
1593 BufferAssItem(PyObject
*self
, PyInt n
, PyObject
*val
)
1595 return RBAssItem((BufferObject
*)(self
), n
, val
, 1,
1596 (PyInt
)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
,
1601 BufferAssSlice(PyObject
*self
, PyInt lo
, PyInt hi
, PyObject
*val
)
1603 return RBAssSlice((BufferObject
*)(self
), lo
, hi
, val
, 1,
1604 (PyInt
)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
,
1609 BufferAppend(PyObject
*self
, PyObject
*args
)
1611 return RBAppend((BufferObject
*)(self
), args
, 1,
1612 (PyInt
)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
,
1617 BufferMark(PyObject
*self
, PyObject
*args
)
1623 if (CheckBuffer((BufferObject
*)(self
)))
1626 if (!PyArg_ParseTuple(args
, "c", &mark
))
1629 curbuf_save
= curbuf
;
1630 curbuf
= ((BufferObject
*)(self
))->buf
;
1631 posp
= getmark(mark
, FALSE
);
1632 curbuf
= curbuf_save
;
1636 PyErr_SetVim(_("invalid mark name"));
1640 /* Ckeck for keyboard interrupt */
1641 if (VimErrorCheck())
1644 if (posp
->lnum
<= 0)
1646 /* Or raise an error? */
1651 return Py_BuildValue("(ll)", (long)(posp
->lnum
), (long)(posp
->col
));
1655 BufferRange(PyObject
*self
, PyObject
*args
)
1660 if (CheckBuffer((BufferObject
*)(self
)))
1663 if (!PyArg_ParseTuple(args
, Py_ssize_t_fmt Py_ssize_t_fmt
, &start
, &end
))
1666 return RangeNew(((BufferObject
*)(self
))->buf
, start
, end
);
1669 /* Line range object - Definitions
1672 static struct PyMethodDef RangeMethods
[] = {
1673 /* name, function, calling, documentation */
1674 {"append", RangeAppend
, 1, "Append data to the Vim range" },
1675 { NULL
, NULL
, 0, NULL
}
1678 static PySequenceMethods RangeAsSeq
= {
1679 (PyInquiry
) RangeLength
, /* sq_length, len(x) */
1680 (binaryfunc
) 0, /* RangeConcat, */ /* sq_concat, x+y */
1681 (PyIntArgFunc
) 0, /* RangeRepeat, */ /* sq_repeat, x*n */
1682 (PyIntArgFunc
) RangeItem
, /* sq_item, x[i] */
1683 (PyIntIntArgFunc
) RangeSlice
, /* sq_slice, x[i:j] */
1684 (PyIntObjArgProc
) RangeAssItem
, /* sq_ass_item, x[i]=v */
1685 (PyIntIntObjArgProc
) RangeAssSlice
, /* sq_ass_slice, x[i:j]=v */
1688 static PyTypeObject RangeType
= {
1689 PyObject_HEAD_INIT(0)
1692 sizeof(RangeObject
),
1695 (destructor
) RangeDestructor
, /* tp_dealloc, refcount==0 */
1696 (printfunc
) 0, /* tp_print, print x */
1697 (getattrfunc
) RangeGetattr
, /* tp_getattr, x.attr */
1698 (setattrfunc
) 0, /* tp_setattr, x.attr=v */
1699 (cmpfunc
) 0, /* tp_compare, x>y */
1700 (reprfunc
) RangeRepr
, /* tp_repr, `x`, print x */
1703 &RangeAsSeq
, /* as sequence */
1706 (hashfunc
) 0, /* tp_hash, dict(x) */
1707 (ternaryfunc
) 0, /* tp_call, x() */
1708 (reprfunc
) 0, /* tp_str, str(x) */
1711 /* Line range object - Implementation
1715 RangeNew(buf_T
*buf
, PyInt start
, PyInt end
)
1719 self
= PyObject_NEW(RangeObject
, &RangeType
);
1723 bufr
= (BufferObject
*)BufferNew(buf
);
1732 self
->start
= start
;
1735 return (PyObject
*)(self
);
1739 RangeDestructor(PyObject
*self
)
1741 Py_DECREF(((RangeObject
*)(self
))->buf
);
1746 RangeGetattr(PyObject
*self
, char *name
)
1748 if (strcmp(name
, "start") == 0)
1749 return Py_BuildValue(Py_ssize_t_fmt
, ((RangeObject
*)(self
))->start
- 1);
1750 else if (strcmp(name
, "end") == 0)
1751 return Py_BuildValue(Py_ssize_t_fmt
, ((RangeObject
*)(self
))->end
- 1);
1753 return Py_FindMethod(RangeMethods
, self
, name
);
1757 RangeRepr(PyObject
*self
)
1759 static char repr
[100];
1760 RangeObject
*this = (RangeObject
*)(self
);
1762 if (this->buf
->buf
== INVALID_BUFFER_VALUE
)
1764 vim_snprintf(repr
, 100, "<range object (for deleted buffer) at %p>",
1766 return PyString_FromString(repr
);
1770 char *name
= (char *)this->buf
->buf
->b_fname
;
1775 len
= (int)strlen(name
);
1778 name
= name
+ (45 - len
);
1780 vim_snprintf(repr
, 100, "<range %s%s (%d:%d)>",
1781 len
> 45 ? "..." : "", name
,
1782 this->start
, this->end
);
1784 return PyString_FromString(repr
);
1791 RangeLength(PyObject
*self
)
1793 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
1794 if (CheckBuffer(((RangeObject
*)(self
))->buf
))
1795 return -1; /* ??? */
1797 return (((RangeObject
*)(self
))->end
- ((RangeObject
*)(self
))->start
+ 1);
1801 RangeItem(PyObject
*self
, PyInt n
)
1803 return RBItem(((RangeObject
*)(self
))->buf
, n
,
1804 ((RangeObject
*)(self
))->start
,
1805 ((RangeObject
*)(self
))->end
);
1809 RangeSlice(PyObject
*self
, PyInt lo
, PyInt hi
)
1811 return RBSlice(((RangeObject
*)(self
))->buf
, lo
, hi
,
1812 ((RangeObject
*)(self
))->start
,
1813 ((RangeObject
*)(self
))->end
);
1817 RangeAssItem(PyObject
*self
, PyInt n
, PyObject
*val
)
1819 return RBAssItem(((RangeObject
*)(self
))->buf
, n
, val
,
1820 ((RangeObject
*)(self
))->start
,
1821 ((RangeObject
*)(self
))->end
,
1822 &((RangeObject
*)(self
))->end
);
1826 RangeAssSlice(PyObject
*self
, PyInt lo
, PyInt hi
, PyObject
*val
)
1828 return RBAssSlice(((RangeObject
*)(self
))->buf
, lo
, hi
, val
,
1829 ((RangeObject
*)(self
))->start
,
1830 ((RangeObject
*)(self
))->end
,
1831 &((RangeObject
*)(self
))->end
);
1835 RangeAppend(PyObject
*self
, PyObject
*args
)
1837 return RBAppend(((RangeObject
*)(self
))->buf
, args
,
1838 ((RangeObject
*)(self
))->start
,
1839 ((RangeObject
*)(self
))->end
,
1840 &((RangeObject
*)(self
))->end
);
1843 /* Buffer list object - Definitions
1852 static PySequenceMethods BufListAsSeq
= {
1853 (PyInquiry
) BufListLength
, /* sq_length, len(x) */
1854 (binaryfunc
) 0, /* sq_concat, x+y */
1855 (PyIntArgFunc
) 0, /* sq_repeat, x*n */
1856 (PyIntArgFunc
) BufListItem
, /* sq_item, x[i] */
1857 (PyIntIntArgFunc
) 0, /* sq_slice, x[i:j] */
1858 (PyIntObjArgProc
) 0, /* sq_ass_item, x[i]=v */
1859 (PyIntIntObjArgProc
) 0, /* sq_ass_slice, x[i:j]=v */
1862 static PyTypeObject BufListType
= {
1863 PyObject_HEAD_INIT(0)
1866 sizeof(BufListObject
),
1869 (destructor
) 0, /* tp_dealloc, refcount==0 */
1870 (printfunc
) 0, /* tp_print, print x */
1871 (getattrfunc
) 0, /* tp_getattr, x.attr */
1872 (setattrfunc
) 0, /* tp_setattr, x.attr=v */
1873 (cmpfunc
) 0, /* tp_compare, x>y */
1874 (reprfunc
) 0, /* tp_repr, `x`, print x */
1877 &BufListAsSeq
, /* as sequence */
1880 (hashfunc
) 0, /* tp_hash, dict(x) */
1881 (ternaryfunc
) 0, /* tp_call, x() */
1882 (reprfunc
) 0, /* tp_str, str(x) */
1885 /* Buffer list object - Implementation
1890 BufListLength(PyObject
*self
)
1892 buf_T
*b
= firstbuf
;
1906 BufListItem(PyObject
*self
, PyInt n
)
1910 for (b
= firstbuf
; b
; b
= b
->b_next
, --n
)
1913 return BufferNew(b
);
1916 PyErr_SetString(PyExc_IndexError
, _("no such buffer"));
1920 /* Window object - Definitions
1923 static struct PyMethodDef WindowMethods
[] = {
1924 /* name, function, calling, documentation */
1925 { NULL
, NULL
, 0, NULL
}
1928 static PyTypeObject WindowType
= {
1929 PyObject_HEAD_INIT(0)
1932 sizeof(WindowObject
),
1935 (destructor
) WindowDestructor
, /* tp_dealloc, refcount==0 */
1936 (printfunc
) 0, /* tp_print, print x */
1937 (getattrfunc
) WindowGetattr
, /* tp_getattr, x.attr */
1938 (setattrfunc
) WindowSetattr
, /* tp_setattr, x.attr=v */
1939 (cmpfunc
) 0, /* tp_compare, x>y */
1940 (reprfunc
) WindowRepr
, /* tp_repr, `x`, print x */
1943 0, /* as sequence */
1946 (hashfunc
) 0, /* tp_hash, dict(x) */
1947 (ternaryfunc
) 0, /* tp_call, x() */
1948 (reprfunc
) 0, /* tp_str, str(x) */
1951 /* Window object - Implementation
1955 WindowNew(win_T
*win
)
1957 /* We need to handle deletion of windows underneath us.
1958 * If we add a "w_python_ref" field to the win_T structure,
1959 * then we can get at it in win_free() in vim. We then
1960 * need to create only ONE Python object per window - if
1961 * we try to create a second, just INCREF the existing one
1962 * and return it. The (single) Python object referring to
1963 * the window is stored in "w_python_ref".
1964 * On a win_free() we set the Python object's win_T* field
1965 * to an invalid value. We trap all uses of a window
1966 * object, and reject them if the win_T* field is invalid.
1971 if (win
->w_python_ref
)
1973 self
= win
->w_python_ref
;
1978 self
= PyObject_NEW(WindowObject
, &WindowType
);
1982 win
->w_python_ref
= self
;
1985 return (PyObject
*)(self
);
1989 WindowDestructor(PyObject
*self
)
1991 WindowObject
*this = (WindowObject
*)(self
);
1993 if (this->win
&& this->win
!= INVALID_WINDOW_VALUE
)
1994 this->win
->w_python_ref
= NULL
;
2000 CheckWindow(WindowObject
*this)
2002 if (this->win
== INVALID_WINDOW_VALUE
)
2004 PyErr_SetVim(_("attempt to refer to deleted window"));
2012 WindowGetattr(PyObject
*self
, char *name
)
2014 WindowObject
*this = (WindowObject
*)(self
);
2016 if (CheckWindow(this))
2019 if (strcmp(name
, "buffer") == 0)
2020 return (PyObject
*)BufferNew(this->win
->w_buffer
);
2021 else if (strcmp(name
, "cursor") == 0)
2023 pos_T
*pos
= &this->win
->w_cursor
;
2025 return Py_BuildValue("(ll)", (long)(pos
->lnum
), (long)(pos
->col
));
2027 else if (strcmp(name
, "height") == 0)
2028 return Py_BuildValue("l", (long)(this->win
->w_height
));
2029 #ifdef FEAT_VERTSPLIT
2030 else if (strcmp(name
, "width") == 0)
2031 return Py_BuildValue("l", (long)(W_WIDTH(this->win
)));
2033 else if (strcmp(name
,"__members__") == 0)
2034 return Py_BuildValue("[sss]", "buffer", "cursor", "height");
2036 return Py_FindMethod(WindowMethods
, self
, name
);
2040 WindowSetattr(PyObject
*self
, char *name
, PyObject
*val
)
2042 WindowObject
*this = (WindowObject
*)(self
);
2044 if (CheckWindow(this))
2047 if (strcmp(name
, "buffer") == 0)
2049 PyErr_SetString(PyExc_TypeError
, _("readonly attribute"));
2052 else if (strcmp(name
, "cursor") == 0)
2057 if (!PyArg_Parse(val
, "(ll)", &lnum
, &col
))
2060 if (lnum
<= 0 || lnum
> this->win
->w_buffer
->b_ml
.ml_line_count
)
2062 PyErr_SetVim(_("cursor position outside buffer"));
2066 /* Check for keyboard interrupts */
2067 if (VimErrorCheck())
2070 /* NO CHECK ON COLUMN - SEEMS NOT TO MATTER */
2072 this->win
->w_cursor
.lnum
= lnum
;
2073 this->win
->w_cursor
.col
= col
;
2074 update_screen(VALID
);
2078 else if (strcmp(name
, "height") == 0)
2083 if (!PyArg_Parse(val
, "i", &height
))
2087 need_mouse_correct
= TRUE
;
2091 win_setheight(height
);
2094 /* Check for keyboard interrupts */
2095 if (VimErrorCheck())
2100 #ifdef FEAT_VERTSPLIT
2101 else if (strcmp(name
, "width") == 0)
2106 if (!PyArg_Parse(val
, "i", &width
))
2110 need_mouse_correct
= TRUE
;
2114 win_setwidth(width
);
2117 /* Check for keyboard interrupts */
2118 if (VimErrorCheck())
2126 PyErr_SetString(PyExc_AttributeError
, name
);
2132 WindowRepr(PyObject
*self
)
2134 static char repr
[100];
2135 WindowObject
*this = (WindowObject
*)(self
);
2137 if (this->win
== INVALID_WINDOW_VALUE
)
2139 vim_snprintf(repr
, 100, _("<window object (deleted) at %p>"), (self
));
2140 return PyString_FromString(repr
);
2147 for (w
= firstwin
; w
!= NULL
&& w
!= this->win
; w
= W_NEXT(w
))
2151 vim_snprintf(repr
, 100, _("<window object (unknown) at %p>"),
2154 vim_snprintf(repr
, 100, _("<window %d>"), i
);
2156 return PyString_FromString(repr
);
2160 /* Window list object - Definitions
2169 static PySequenceMethods WinListAsSeq
= {
2170 (PyInquiry
) WinListLength
, /* sq_length, len(x) */
2171 (binaryfunc
) 0, /* sq_concat, x+y */
2172 (PyIntArgFunc
) 0, /* sq_repeat, x*n */
2173 (PyIntArgFunc
) WinListItem
, /* sq_item, x[i] */
2174 (PyIntIntArgFunc
) 0, /* sq_slice, x[i:j] */
2175 (PyIntObjArgProc
) 0, /* sq_ass_item, x[i]=v */
2176 (PyIntIntObjArgProc
) 0, /* sq_ass_slice, x[i:j]=v */
2179 static PyTypeObject WinListType
= {
2180 PyObject_HEAD_INIT(0)
2183 sizeof(WinListObject
),
2186 (destructor
) 0, /* tp_dealloc, refcount==0 */
2187 (printfunc
) 0, /* tp_print, print x */
2188 (getattrfunc
) 0, /* tp_getattr, x.attr */
2189 (setattrfunc
) 0, /* tp_setattr, x.attr=v */
2190 (cmpfunc
) 0, /* tp_compare, x>y */
2191 (reprfunc
) 0, /* tp_repr, `x`, print x */
2194 &WinListAsSeq
, /* as sequence */
2197 (hashfunc
) 0, /* tp_hash, dict(x) */
2198 (ternaryfunc
) 0, /* tp_call, x() */
2199 (reprfunc
) 0, /* tp_str, str(x) */
2202 /* Window list object - Implementation
2206 WinListLength(PyObject
*self
)
2208 win_T
*w
= firstwin
;
2222 WinListItem(PyObject
*self
, PyInt n
)
2226 for (w
= firstwin
; w
!= NULL
; w
= W_NEXT(w
), --n
)
2228 return WindowNew(w
);
2230 PyErr_SetString(PyExc_IndexError
, _("no such window"));
2234 /* Current items object - Definitions
2243 static PyTypeObject CurrentType
= {
2244 PyObject_HEAD_INIT(0)
2247 sizeof(CurrentObject
),
2250 (destructor
) 0, /* tp_dealloc, refcount==0 */
2251 (printfunc
) 0, /* tp_print, print x */
2252 (getattrfunc
) CurrentGetattr
, /* tp_getattr, x.attr */
2253 (setattrfunc
) CurrentSetattr
, /* tp_setattr, x.attr=v */
2254 (cmpfunc
) 0, /* tp_compare, x>y */
2255 (reprfunc
) 0, /* tp_repr, `x`, print x */
2258 0, /* as sequence */
2261 (hashfunc
) 0, /* tp_hash, dict(x) */
2262 (ternaryfunc
) 0, /* tp_call, x() */
2263 (reprfunc
) 0, /* tp_str, str(x) */
2266 /* Current items object - Implementation
2270 CurrentGetattr(PyObject
*self
, char *name
)
2272 if (strcmp(name
, "buffer") == 0)
2273 return (PyObject
*)BufferNew(curbuf
);
2274 else if (strcmp(name
, "window") == 0)
2275 return (PyObject
*)WindowNew(curwin
);
2276 else if (strcmp(name
, "line") == 0)
2277 return GetBufferLine(curbuf
, (PyInt
)curwin
->w_cursor
.lnum
);
2278 else if (strcmp(name
, "range") == 0)
2279 return RangeNew(curbuf
, RangeStart
, RangeEnd
);
2280 else if (strcmp(name
,"__members__") == 0)
2281 return Py_BuildValue("[ssss]", "buffer", "window", "line", "range");
2284 PyErr_SetString(PyExc_AttributeError
, name
);
2291 CurrentSetattr(PyObject
*self
, char *name
, PyObject
*value
)
2293 if (strcmp(name
, "line") == 0)
2295 if (SetBufferLine(curbuf
, (PyInt
)curwin
->w_cursor
.lnum
, value
, NULL
) == FAIL
)
2302 PyErr_SetString(PyExc_AttributeError
, name
);
2307 /* External interface
2311 python_buffer_free(buf_T
*buf
)
2313 if (buf
->b_python_ref
!= NULL
)
2315 BufferObject
*bp
= buf
->b_python_ref
;
2316 bp
->buf
= INVALID_BUFFER_VALUE
;
2317 buf
->b_python_ref
= NULL
;
2321 #if defined(FEAT_WINDOWS) || defined(PROTO)
2323 python_window_free(win_T
*win
)
2325 if (win
->w_python_ref
!= NULL
)
2327 WindowObject
*wp
= win
->w_python_ref
;
2328 wp
->win
= INVALID_WINDOW_VALUE
;
2329 win
->w_python_ref
= NULL
;
2334 static BufListObject TheBufferList
=
2336 PyObject_HEAD_INIT(&BufListType
)
2339 static WinListObject TheWindowList
=
2341 PyObject_HEAD_INIT(&WinListType
)
2344 static CurrentObject TheCurrent
=
2346 PyObject_HEAD_INIT(&CurrentType
)
2350 PythonMod_Init(void)
2354 /* The special value is removed from sys.path in Python_Init(). */
2355 static char *(argv
[2]) = {"/must>not&exist/foo", NULL
};
2358 BufferType
.ob_type
= &PyType_Type
;
2359 RangeType
.ob_type
= &PyType_Type
;
2360 WindowType
.ob_type
= &PyType_Type
;
2361 BufListType
.ob_type
= &PyType_Type
;
2362 WinListType
.ob_type
= &PyType_Type
;
2363 CurrentType
.ob_type
= &PyType_Type
;
2365 /* Set sys.argv[] to avoid a crash in warn(). */
2366 PySys_SetArgv(1, argv
);
2368 mod
= Py_InitModule4("vim", VimMethods
, (char *)NULL
, (PyObject
*)NULL
, PYTHON_API_VERSION
);
2369 dict
= PyModule_GetDict(mod
);
2371 VimError
= Py_BuildValue("s", "vim.error");
2373 PyDict_SetItemString(dict
, "error", VimError
);
2374 PyDict_SetItemString(dict
, "buffers", (PyObject
*)(void *)&TheBufferList
);
2375 PyDict_SetItemString(dict
, "current", (PyObject
*)(void *)&TheCurrent
);
2376 PyDict_SetItemString(dict
, "windows", (PyObject
*)(void *)&TheWindowList
);
2378 if (PyErr_Occurred())
2384 /*************************************************************************
2385 * 4. Utility functions for handling the interface between Vim and Python.
2388 /* Get a line from the specified buffer. The line number is
2389 * in Vim format (1-based). The line is returned as a Python
2393 GetBufferLine(buf_T
*buf
, PyInt n
)
2395 return LineToString((char *)ml_get_buf(buf
, (linenr_T
)n
, FALSE
));
2398 /* Get a list of lines from the specified buffer. The line numbers
2399 * are in Vim format (1-based). The range is from lo up to, but not
2400 * including, hi. The list is returned as a Python list of string objects.
2403 GetBufferLineList(buf_T
*buf
, PyInt lo
, PyInt hi
)
2407 PyObject
*list
= PyList_New(n
);
2412 for (i
= 0; i
< n
; ++i
)
2414 PyObject
*str
= LineToString((char *)ml_get_buf(buf
, (linenr_T
)(lo
+i
), FALSE
));
2416 /* Error check - was the Python string creation OK? */
2423 /* Set the list item */
2424 if (PyList_SetItem(list
, i
, str
))
2432 /* The ownership of the Python list is passed to the caller (ie,
2433 * the caller should Py_DECREF() the object when it is finished
2441 * Check if deleting lines made the cursor position invalid.
2442 * Changed the lines from "lo" to "hi" and added "extra" lines (negative if
2446 py_fix_cursor(linenr_T lo
, linenr_T hi
, linenr_T extra
)
2448 if (curwin
->w_cursor
.lnum
>= lo
)
2450 /* Adjust the cursor position if it's in/after the changed
2452 if (curwin
->w_cursor
.lnum
>= hi
)
2454 curwin
->w_cursor
.lnum
+= extra
;
2459 curwin
->w_cursor
.lnum
= lo
;
2464 changed_cline_bef_curs();
2466 invalidate_botline();
2469 /* Replace a line in the specified buffer. The line number is
2470 * in Vim format (1-based). The replacement line is given as
2471 * a Python string object. The object is checked for validity
2472 * and correct format. Errors are returned as a value of FAIL.
2473 * The return value is OK on success.
2474 * If OK is returned and len_change is not NULL, *len_change
2475 * is set to the change in the buffer length.
2478 SetBufferLine(buf_T
*buf
, PyInt n
, PyObject
*line
, PyInt
*len_change
)
2480 /* First of all, we check the thpe of the supplied Python object.
2481 * There are three cases:
2482 * 1. NULL, or None - this is a deletion.
2483 * 2. A string - this is a replacement.
2484 * 3. Anything else - this is an error.
2486 if (line
== Py_None
|| line
== NULL
)
2488 buf_T
*savebuf
= curbuf
;
2493 if (u_savedel((linenr_T
)n
, 1L) == FAIL
)
2494 PyErr_SetVim(_("cannot save undo information"));
2495 else if (ml_delete((linenr_T
)n
, FALSE
) == FAIL
)
2496 PyErr_SetVim(_("cannot delete line"));
2499 deleted_lines_mark((linenr_T
)n
, 1L);
2500 if (buf
== curwin
->w_buffer
)
2501 py_fix_cursor((linenr_T
)n
, (linenr_T
)n
+ 1, (linenr_T
)-1);
2506 if (PyErr_Occurred() || VimErrorCheck())
2514 else if (PyString_Check(line
))
2516 char *save
= StringToLine(line
);
2517 buf_T
*savebuf
= curbuf
;
2522 /* We do not need to free "save" if ml_replace() consumes it. */
2526 if (u_savesub((linenr_T
)n
) == FAIL
)
2528 PyErr_SetVim(_("cannot save undo information"));
2531 else if (ml_replace((linenr_T
)n
, (char_u
*)save
, FALSE
) == FAIL
)
2533 PyErr_SetVim(_("cannot replace line"));
2537 changed_bytes((linenr_T
)n
, 0);
2541 /* Check that the cursor is not beyond the end of the line now. */
2542 if (buf
== curwin
->w_buffer
)
2545 if (PyErr_Occurred() || VimErrorCheck())
2555 PyErr_BadArgument();
2560 /* Replace a range of lines in the specified buffer. The line numbers are in
2561 * Vim format (1-based). The range is from lo up to, but not including, hi.
2562 * The replacement lines are given as a Python list of string objects. The
2563 * list is checked for validity and correct format. Errors are returned as a
2564 * value of FAIL. The return value is OK on success.
2565 * If OK is returned and len_change is not NULL, *len_change
2566 * is set to the change in the buffer length.
2569 SetBufferLineList(buf_T
*buf
, PyInt lo
, PyInt hi
, PyObject
*list
, PyInt
*len_change
)
2571 /* First of all, we check the thpe of the supplied Python object.
2572 * There are three cases:
2573 * 1. NULL, or None - this is a deletion.
2574 * 2. A list - this is a replacement.
2575 * 3. Anything else - this is an error.
2577 if (list
== Py_None
|| list
== NULL
)
2580 PyInt n
= (int)(hi
- lo
);
2581 buf_T
*savebuf
= curbuf
;
2586 if (u_savedel((linenr_T
)lo
, (long)n
) == FAIL
)
2587 PyErr_SetVim(_("cannot save undo information"));
2590 for (i
= 0; i
< n
; ++i
)
2592 if (ml_delete((linenr_T
)lo
, FALSE
) == FAIL
)
2594 PyErr_SetVim(_("cannot delete line"));
2598 deleted_lines_mark((linenr_T
)lo
, (long)i
);
2600 if (buf
== curwin
->w_buffer
)
2601 py_fix_cursor((linenr_T
)lo
, (linenr_T
)hi
, (linenr_T
)-n
);
2606 if (PyErr_Occurred() || VimErrorCheck())
2614 else if (PyList_Check(list
))
2617 PyInt new_len
= PyList_Size(list
);
2618 PyInt old_len
= hi
- lo
;
2619 PyInt extra
= 0; /* lines added to text, can be negative */
2623 if (new_len
== 0) /* avoid allocating zero bytes */
2627 array
= (char **)alloc((unsigned)(new_len
* sizeof(char *)));
2635 for (i
= 0; i
< new_len
; ++i
)
2637 PyObject
*line
= PyList_GetItem(list
, i
);
2639 array
[i
] = StringToLine(line
);
2640 if (array
[i
] == NULL
)
2643 vim_free(array
[--i
]);
2654 if (u_save((linenr_T
)(lo
-1), (linenr_T
)hi
) == FAIL
)
2655 PyErr_SetVim(_("cannot save undo information"));
2657 /* If the size of the range is reducing (ie, new_len < old_len) we
2658 * need to delete some old_len. We do this at the start, by
2659 * repeatedly deleting line "lo".
2661 if (!PyErr_Occurred())
2663 for (i
= 0; i
< old_len
- new_len
; ++i
)
2664 if (ml_delete((linenr_T
)lo
, FALSE
) == FAIL
)
2666 PyErr_SetVim(_("cannot delete line"));
2672 /* For as long as possible, replace the existing old_len with the
2673 * new old_len. This is a more efficient operation, as it requires
2674 * less memory allocation and freeing.
2676 if (!PyErr_Occurred())
2678 for (i
= 0; i
< old_len
&& i
< new_len
; ++i
)
2679 if (ml_replace((linenr_T
)(lo
+i
), (char_u
*)array
[i
], FALSE
)
2682 PyErr_SetVim(_("cannot replace line"));
2689 /* Now we may need to insert the remaining new old_len. If we do, we
2690 * must free the strings as we finish with them (we can't pass the
2691 * responsibility to vim in this case).
2693 if (!PyErr_Occurred())
2697 if (ml_append((linenr_T
)(lo
+ i
- 1),
2698 (char_u
*)array
[i
], 0, FALSE
) == FAIL
)
2700 PyErr_SetVim(_("cannot insert line"));
2709 /* Free any left-over old_len, as a result of an error */
2716 /* Free the array of old_len. All of its contents have now
2717 * been dealt with (either freed, or the responsibility passed
2722 /* Adjust marks. Invalidate any which lie in the
2723 * changed range, and move any in the remainder of the buffer.
2725 mark_adjust((linenr_T
)lo
, (linenr_T
)(hi
- 1),
2726 (long)MAXLNUM
, (long)extra
);
2727 changed_lines((linenr_T
)lo
, 0, (linenr_T
)hi
, (long)extra
);
2729 if (buf
== curwin
->w_buffer
)
2730 py_fix_cursor((linenr_T
)lo
, (linenr_T
)hi
, (linenr_T
)extra
);
2734 if (PyErr_Occurred() || VimErrorCheck())
2738 *len_change
= new_len
- old_len
;
2744 PyErr_BadArgument();
2749 /* Insert a number of lines into the specified buffer after the specifed line.
2750 * The line number is in Vim format (1-based). The lines to be inserted are
2751 * given as a Python list of string objects or as a single string. The lines
2752 * to be added are checked for validity and correct format. Errors are
2753 * returned as a value of FAIL. The return value is OK on success.
2754 * If OK is returned and len_change is not NULL, *len_change
2755 * is set to the change in the buffer length.
2758 InsertBufferLines(buf_T
*buf
, PyInt n
, PyObject
*lines
, PyInt
*len_change
)
2760 /* First of all, we check the type of the supplied Python object.
2761 * It must be a string or a list, or the call is in error.
2763 if (PyString_Check(lines
))
2765 char *str
= StringToLine(lines
);
2776 if (u_save((linenr_T
)n
, (linenr_T
)(n
+1)) == FAIL
)
2777 PyErr_SetVim(_("cannot save undo information"));
2778 else if (ml_append((linenr_T
)n
, (char_u
*)str
, 0, FALSE
) == FAIL
)
2779 PyErr_SetVim(_("cannot insert line"));
2781 appended_lines_mark((linenr_T
)n
, 1L);
2785 update_screen(VALID
);
2787 if (PyErr_Occurred() || VimErrorCheck())
2795 else if (PyList_Check(lines
))
2798 PyInt size
= PyList_Size(lines
);
2802 array
= (char **)alloc((unsigned)(size
* sizeof(char *)));
2809 for (i
= 0; i
< size
; ++i
)
2811 PyObject
*line
= PyList_GetItem(lines
, i
);
2812 array
[i
] = StringToLine(line
);
2814 if (array
[i
] == NULL
)
2817 vim_free(array
[--i
]);
2828 if (u_save((linenr_T
)n
, (linenr_T
)(n
+ 1)) == FAIL
)
2829 PyErr_SetVim(_("cannot save undo information"));
2832 for (i
= 0; i
< size
; ++i
)
2834 if (ml_append((linenr_T
)(n
+ i
),
2835 (char_u
*)array
[i
], 0, FALSE
) == FAIL
)
2837 PyErr_SetVim(_("cannot insert line"));
2839 /* Free the rest of the lines */
2841 vim_free(array
[i
++]);
2848 appended_lines_mark((linenr_T
)n
, (long)i
);
2851 /* Free the array of lines. All of its contents have now
2857 update_screen(VALID
);
2859 if (PyErr_Occurred() || VimErrorCheck())
2869 PyErr_BadArgument();
2874 /* Convert a Vim line into a Python string.
2875 * All internal newlines are replaced by null characters.
2877 * On errors, the Python exception data is set, and NULL is returned.
2880 LineToString(const char *str
)
2883 PyInt len
= strlen(str
);
2886 /* Allocate an Python string object, with uninitialised contents. We
2887 * must do it this way, so that we can modify the string in place
2888 * later. See the Python source, Objects/stringobject.c for details.
2890 result
= PyString_FromStringAndSize(NULL
, len
);
2894 p
= PyString_AsString(result
);
2910 /* Convert a Python string into a Vim line.
2912 * The result is in allocated memory. All internal nulls are replaced by
2913 * newline characters. It is an error for the string to contain newline
2916 * On errors, the Python exception data is set, and NULL is returned.
2919 StringToLine(PyObject
*obj
)
2927 if (obj
== NULL
|| !PyString_Check(obj
))
2929 PyErr_BadArgument();
2933 str
= PyString_AsString(obj
);
2934 len
= PyString_Size(obj
);
2937 * Error checking: String must not contain newlines, as we
2938 * are replacing a single line, and we must replace it with
2940 * A trailing newline is removed, so that append(f.readlines()) works.
2942 p
= memchr(str
, '\n', len
);
2945 if (p
== str
+ len
- 1)
2949 PyErr_SetVim(_("string cannot contain newlines"));
2954 /* Create a copy of the string, with internal nulls replaced by
2955 * newline characters, as is the vim convention.
2957 save
= (char *)alloc((unsigned)(len
+1));
2964 for (i
= 0; i
< len
; ++i
)
2977 /* Check to see whether a Vim error has been reported, or a keyboard
2978 * interrupt has been detected.
2985 PyErr_SetNone(PyExc_KeyboardInterrupt
);
2988 else if (did_emsg
&& !PyErr_Occurred())
2990 PyErr_SetNone(VimError
);
2998 /* Don't generate a prototype for the next function, it generates an error on
2999 * newer Python versions. */
3000 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */ && !defined(PROTO)
3003 Py_GetProgramName(void)
3007 #endif /* Python 1.4 */