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 if ((our_tv
->v_type
== VAR_LIST
&& our_tv
->vval
.v_list
!= NULL
)
1155 || (our_tv
->v_type
== VAR_DICT
&& our_tv
->vval
.v_dict
!= NULL
))
1157 sprintf(ptrBuf
, PRINTF_DECIMAL_LONG_U
,
1158 our_tv
->v_type
== VAR_LIST
? (long_u
)our_tv
->vval
.v_list
1159 : (long_u
)our_tv
->vval
.v_dict
);
1160 result
= PyDict_GetItemString(lookupDict
, ptrBuf
);
1168 if (our_tv
->v_type
== VAR_STRING
)
1170 result
= Py_BuildValue("s", our_tv
->vval
.v_string
);
1172 else if (our_tv
->v_type
== VAR_NUMBER
)
1174 char buf
[NUMBUFLEN
];
1176 /* For backwards compatibility numbers are stored as strings. */
1177 sprintf(buf
, "%ld", (long)our_tv
->vval
.v_number
);
1178 result
= Py_BuildValue("s", buf
);
1181 else if (our_tv
->v_type
== VAR_FLOAT
)
1183 char buf
[NUMBUFLEN
];
1185 sprintf(buf
, "%f", our_tv
->vval
.v_float
);
1186 result
= Py_BuildValue("s", buf
);
1189 else if (our_tv
->v_type
== VAR_LIST
)
1191 list_T
*list
= our_tv
->vval
.v_list
;
1194 result
= PyList_New(0);
1198 PyDict_SetItemString(lookupDict
, ptrBuf
, result
);
1200 for (curr
= list
->lv_first
; curr
!= NULL
; curr
= curr
->li_next
)
1202 newObj
= VimToPython(&curr
->li_tv
, depth
+ 1, lookupDict
);
1203 PyList_Append(result
, newObj
);
1208 else if (our_tv
->v_type
== VAR_DICT
)
1210 result
= PyDict_New();
1212 if (our_tv
->vval
.v_dict
!= NULL
)
1214 hashtab_T
*ht
= &our_tv
->vval
.v_dict
->dv_hashtab
;
1215 long_u todo
= ht
->ht_used
;
1219 PyDict_SetItemString(lookupDict
, ptrBuf
, result
);
1221 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
1223 if (!HASHITEM_EMPTY(hi
))
1227 di
= dict_lookup(hi
);
1228 newObj
= VimToPython(&di
->di_tv
, depth
+ 1, lookupDict
);
1229 PyDict_SetItemString(result
, (char *)hi
->hi_key
, newObj
);
1247 VimEval(PyObject
*self
, PyObject
*args
)
1253 PyObject
*lookup_dict
;
1255 if (!PyArg_ParseTuple(args
, "s", &expr
))
1258 Py_BEGIN_ALLOW_THREADS
1260 our_tv
= eval_expr((char_u
*)expr
, NULL
);
1262 Python_Release_Vim();
1263 Py_END_ALLOW_THREADS
1267 PyErr_SetVim(_("invalid expression"));
1271 /* Convert the Vim type into a Python type. Create a dictionary that's
1272 * used to check for recursive loops. */
1273 lookup_dict
= PyDict_New();
1274 result
= VimToPython(our_tv
, 1, lookup_dict
);
1275 Py_DECREF(lookup_dict
);
1278 Py_BEGIN_ALLOW_THREADS
1281 Python_Release_Vim();
1282 Py_END_ALLOW_THREADS
1286 PyErr_SetVim(_("expressions disabled at compile time"));
1291 /* Common routines for buffers and line ranges
1292 * -------------------------------------------
1295 CheckBuffer(BufferObject
*this)
1297 if (this->buf
== INVALID_BUFFER_VALUE
)
1299 PyErr_SetVim(_("attempt to refer to deleted buffer"));
1307 RBItem(BufferObject
*self
, PyInt n
, PyInt start
, PyInt end
)
1309 if (CheckBuffer(self
))
1312 if (n
< 0 || n
> end
- start
)
1314 PyErr_SetString(PyExc_IndexError
, _("line number out of range"));
1318 return GetBufferLine(self
->buf
, n
+start
);
1322 RBSlice(BufferObject
*self
, PyInt lo
, PyInt hi
, PyInt start
, PyInt end
)
1326 if (CheckBuffer(self
))
1329 size
= end
- start
+ 1;
1342 return GetBufferLineList(self
->buf
, lo
+start
, hi
+start
);
1346 RBAssItem(BufferObject
*self
, PyInt n
, PyObject
*val
, PyInt start
, PyInt end
, PyInt
*new_end
)
1350 if (CheckBuffer(self
))
1353 if (n
< 0 || n
> end
- start
)
1355 PyErr_SetString(PyExc_IndexError
, _("line number out of range"));
1359 if (SetBufferLine(self
->buf
, n
+start
, val
, &len_change
) == FAIL
)
1363 *new_end
= end
+ len_change
;
1369 RBAssSlice(BufferObject
*self
, PyInt lo
, PyInt hi
, PyObject
*val
, PyInt start
, PyInt end
, PyInt
*new_end
)
1374 /* Self must be a valid buffer */
1375 if (CheckBuffer(self
))
1378 /* Sort out the slice range */
1379 size
= end
- start
+ 1;
1392 if (SetBufferLineList(self
->buf
, lo
+start
, hi
+start
, val
, &len_change
) == FAIL
)
1396 *new_end
= end
+ len_change
;
1402 RBAppend(BufferObject
*self
, PyObject
*args
, PyInt start
, PyInt end
, PyInt
*new_end
)
1409 if (CheckBuffer(self
))
1412 max
= n
= end
- start
+ 1;
1414 if (!PyArg_ParseTuple(args
, "O|" Py_ssize_t_fmt
, &lines
, &n
))
1417 if (n
< 0 || n
> max
)
1419 PyErr_SetString(PyExc_ValueError
, _("line number out of range"));
1423 if (InsertBufferLines(self
->buf
, n
+ start
- 1, lines
, &len_change
) == FAIL
)
1427 *new_end
= end
+ len_change
;
1434 /* Buffer object - Definitions
1437 static struct PyMethodDef BufferMethods
[] = {
1438 /* name, function, calling, documentation */
1439 {"append", BufferAppend
, 1, "Append data to Vim buffer" },
1440 {"mark", BufferMark
, 1, "Return (row,col) representing position of named mark" },
1441 {"range", BufferRange
, 1, "Return a range object which represents the part of the given buffer between line numbers s and e" },
1442 { NULL
, NULL
, 0, NULL
}
1445 static PySequenceMethods BufferAsSeq
= {
1446 (PyInquiry
) BufferLength
, /* sq_length, len(x) */
1447 (binaryfunc
) 0, /* BufferConcat, */ /* sq_concat, x+y */
1448 (PyIntArgFunc
) 0, /* BufferRepeat, */ /* sq_repeat, x*n */
1449 (PyIntArgFunc
) BufferItem
, /* sq_item, x[i] */
1450 (PyIntIntArgFunc
) BufferSlice
, /* sq_slice, x[i:j] */
1451 (PyIntObjArgProc
) BufferAssItem
, /* sq_ass_item, x[i]=v */
1452 (PyIntIntObjArgProc
) BufferAssSlice
, /* sq_ass_slice, x[i:j]=v */
1455 static PyTypeObject BufferType
= {
1456 PyObject_HEAD_INIT(0)
1459 sizeof(BufferObject
),
1462 (destructor
) BufferDestructor
, /* tp_dealloc, refcount==0 */
1463 (printfunc
) 0, /* tp_print, print x */
1464 (getattrfunc
) BufferGetattr
, /* tp_getattr, x.attr */
1465 (setattrfunc
) 0, /* tp_setattr, x.attr=v */
1466 (cmpfunc
) 0, /* tp_compare, x>y */
1467 (reprfunc
) BufferRepr
, /* tp_repr, `x`, print x */
1470 &BufferAsSeq
, /* as sequence */
1473 (hashfunc
) 0, /* tp_hash, dict(x) */
1474 (ternaryfunc
) 0, /* tp_call, x() */
1475 (reprfunc
) 0, /* tp_str, str(x) */
1478 /* Buffer object - Implementation
1482 BufferNew(buf_T
*buf
)
1484 /* We need to handle deletion of buffers underneath us.
1485 * If we add a "b_python_ref" field to the buf_T structure,
1486 * then we can get at it in buf_freeall() in vim. We then
1487 * need to create only ONE Python object per buffer - if
1488 * we try to create a second, just INCREF the existing one
1489 * and return it. The (single) Python object referring to
1490 * the buffer is stored in "b_python_ref".
1491 * Question: what to do on a buf_freeall(). We'll probably
1492 * have to either delete the Python object (DECREF it to
1493 * zero - a bad idea, as it leaves dangling refs!) or
1494 * set the buf_T * value to an invalid value (-1?), which
1495 * means we need checks in all access functions... Bah.
1500 if (buf
->b_python_ref
!= NULL
)
1502 self
= buf
->b_python_ref
;
1507 self
= PyObject_NEW(BufferObject
, &BufferType
);
1511 buf
->b_python_ref
= self
;
1514 return (PyObject
*)(self
);
1518 BufferDestructor(PyObject
*self
)
1520 BufferObject
*this = (BufferObject
*)(self
);
1522 if (this->buf
&& this->buf
!= INVALID_BUFFER_VALUE
)
1523 this->buf
->b_python_ref
= NULL
;
1529 BufferGetattr(PyObject
*self
, char *name
)
1531 BufferObject
*this = (BufferObject
*)(self
);
1533 if (CheckBuffer(this))
1536 if (strcmp(name
, "name") == 0)
1537 return Py_BuildValue("s", this->buf
->b_ffname
);
1538 else if (strcmp(name
, "number") == 0)
1539 return Py_BuildValue(Py_ssize_t_fmt
, this->buf
->b_fnum
);
1540 else if (strcmp(name
,"__members__") == 0)
1541 return Py_BuildValue("[ss]", "name", "number");
1543 return Py_FindMethod(BufferMethods
, self
, name
);
1547 BufferRepr(PyObject
*self
)
1549 static char repr
[100];
1550 BufferObject
*this = (BufferObject
*)(self
);
1552 if (this->buf
== INVALID_BUFFER_VALUE
)
1554 vim_snprintf(repr
, 100, _("<buffer object (deleted) at %p>"), (self
));
1555 return PyString_FromString(repr
);
1559 char *name
= (char *)this->buf
->b_fname
;
1567 name
= name
+ (35 - len
);
1569 vim_snprintf(repr
, 100, "<buffer %s%s>", len
> 35 ? "..." : "", name
);
1571 return PyString_FromString(repr
);
1575 /******************/
1578 BufferLength(PyObject
*self
)
1580 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
1581 if (CheckBuffer((BufferObject
*)(self
)))
1582 return -1; /* ??? */
1584 return (((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
);
1588 BufferItem(PyObject
*self
, PyInt n
)
1590 return RBItem((BufferObject
*)(self
), n
, 1,
1591 (int)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
);
1595 BufferSlice(PyObject
*self
, PyInt lo
, PyInt hi
)
1597 return RBSlice((BufferObject
*)(self
), lo
, hi
, 1,
1598 (int)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
);
1602 BufferAssItem(PyObject
*self
, PyInt n
, PyObject
*val
)
1604 return RBAssItem((BufferObject
*)(self
), n
, val
, 1,
1605 (PyInt
)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
,
1610 BufferAssSlice(PyObject
*self
, PyInt lo
, PyInt hi
, PyObject
*val
)
1612 return RBAssSlice((BufferObject
*)(self
), lo
, hi
, val
, 1,
1613 (PyInt
)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
,
1618 BufferAppend(PyObject
*self
, PyObject
*args
)
1620 return RBAppend((BufferObject
*)(self
), args
, 1,
1621 (PyInt
)((BufferObject
*)(self
))->buf
->b_ml
.ml_line_count
,
1626 BufferMark(PyObject
*self
, PyObject
*args
)
1632 if (CheckBuffer((BufferObject
*)(self
)))
1635 if (!PyArg_ParseTuple(args
, "c", &mark
))
1638 curbuf_save
= curbuf
;
1639 curbuf
= ((BufferObject
*)(self
))->buf
;
1640 posp
= getmark(mark
, FALSE
);
1641 curbuf
= curbuf_save
;
1645 PyErr_SetVim(_("invalid mark name"));
1649 /* Ckeck for keyboard interrupt */
1650 if (VimErrorCheck())
1653 if (posp
->lnum
<= 0)
1655 /* Or raise an error? */
1660 return Py_BuildValue("(ll)", (long)(posp
->lnum
), (long)(posp
->col
));
1664 BufferRange(PyObject
*self
, PyObject
*args
)
1669 if (CheckBuffer((BufferObject
*)(self
)))
1672 if (!PyArg_ParseTuple(args
, Py_ssize_t_fmt Py_ssize_t_fmt
, &start
, &end
))
1675 return RangeNew(((BufferObject
*)(self
))->buf
, start
, end
);
1678 /* Line range object - Definitions
1681 static struct PyMethodDef RangeMethods
[] = {
1682 /* name, function, calling, documentation */
1683 {"append", RangeAppend
, 1, "Append data to the Vim range" },
1684 { NULL
, NULL
, 0, NULL
}
1687 static PySequenceMethods RangeAsSeq
= {
1688 (PyInquiry
) RangeLength
, /* sq_length, len(x) */
1689 (binaryfunc
) 0, /* RangeConcat, */ /* sq_concat, x+y */
1690 (PyIntArgFunc
) 0, /* RangeRepeat, */ /* sq_repeat, x*n */
1691 (PyIntArgFunc
) RangeItem
, /* sq_item, x[i] */
1692 (PyIntIntArgFunc
) RangeSlice
, /* sq_slice, x[i:j] */
1693 (PyIntObjArgProc
) RangeAssItem
, /* sq_ass_item, x[i]=v */
1694 (PyIntIntObjArgProc
) RangeAssSlice
, /* sq_ass_slice, x[i:j]=v */
1697 static PyTypeObject RangeType
= {
1698 PyObject_HEAD_INIT(0)
1701 sizeof(RangeObject
),
1704 (destructor
) RangeDestructor
, /* tp_dealloc, refcount==0 */
1705 (printfunc
) 0, /* tp_print, print x */
1706 (getattrfunc
) RangeGetattr
, /* tp_getattr, x.attr */
1707 (setattrfunc
) 0, /* tp_setattr, x.attr=v */
1708 (cmpfunc
) 0, /* tp_compare, x>y */
1709 (reprfunc
) RangeRepr
, /* tp_repr, `x`, print x */
1712 &RangeAsSeq
, /* as sequence */
1715 (hashfunc
) 0, /* tp_hash, dict(x) */
1716 (ternaryfunc
) 0, /* tp_call, x() */
1717 (reprfunc
) 0, /* tp_str, str(x) */
1720 /* Line range object - Implementation
1724 RangeNew(buf_T
*buf
, PyInt start
, PyInt end
)
1728 self
= PyObject_NEW(RangeObject
, &RangeType
);
1732 bufr
= (BufferObject
*)BufferNew(buf
);
1741 self
->start
= start
;
1744 return (PyObject
*)(self
);
1748 RangeDestructor(PyObject
*self
)
1750 Py_DECREF(((RangeObject
*)(self
))->buf
);
1755 RangeGetattr(PyObject
*self
, char *name
)
1757 if (strcmp(name
, "start") == 0)
1758 return Py_BuildValue(Py_ssize_t_fmt
, ((RangeObject
*)(self
))->start
- 1);
1759 else if (strcmp(name
, "end") == 0)
1760 return Py_BuildValue(Py_ssize_t_fmt
, ((RangeObject
*)(self
))->end
- 1);
1762 return Py_FindMethod(RangeMethods
, self
, name
);
1766 RangeRepr(PyObject
*self
)
1768 static char repr
[100];
1769 RangeObject
*this = (RangeObject
*)(self
);
1771 if (this->buf
->buf
== INVALID_BUFFER_VALUE
)
1773 vim_snprintf(repr
, 100, "<range object (for deleted buffer) at %p>",
1775 return PyString_FromString(repr
);
1779 char *name
= (char *)this->buf
->buf
->b_fname
;
1784 len
= (int)strlen(name
);
1787 name
= name
+ (45 - len
);
1789 vim_snprintf(repr
, 100, "<range %s%s (%d:%d)>",
1790 len
> 45 ? "..." : "", name
,
1791 this->start
, this->end
);
1793 return PyString_FromString(repr
);
1800 RangeLength(PyObject
*self
)
1802 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
1803 if (CheckBuffer(((RangeObject
*)(self
))->buf
))
1804 return -1; /* ??? */
1806 return (((RangeObject
*)(self
))->end
- ((RangeObject
*)(self
))->start
+ 1);
1810 RangeItem(PyObject
*self
, PyInt n
)
1812 return RBItem(((RangeObject
*)(self
))->buf
, n
,
1813 ((RangeObject
*)(self
))->start
,
1814 ((RangeObject
*)(self
))->end
);
1818 RangeSlice(PyObject
*self
, PyInt lo
, PyInt hi
)
1820 return RBSlice(((RangeObject
*)(self
))->buf
, lo
, hi
,
1821 ((RangeObject
*)(self
))->start
,
1822 ((RangeObject
*)(self
))->end
);
1826 RangeAssItem(PyObject
*self
, PyInt n
, PyObject
*val
)
1828 return RBAssItem(((RangeObject
*)(self
))->buf
, n
, val
,
1829 ((RangeObject
*)(self
))->start
,
1830 ((RangeObject
*)(self
))->end
,
1831 &((RangeObject
*)(self
))->end
);
1835 RangeAssSlice(PyObject
*self
, PyInt lo
, PyInt hi
, PyObject
*val
)
1837 return RBAssSlice(((RangeObject
*)(self
))->buf
, lo
, hi
, val
,
1838 ((RangeObject
*)(self
))->start
,
1839 ((RangeObject
*)(self
))->end
,
1840 &((RangeObject
*)(self
))->end
);
1844 RangeAppend(PyObject
*self
, PyObject
*args
)
1846 return RBAppend(((RangeObject
*)(self
))->buf
, args
,
1847 ((RangeObject
*)(self
))->start
,
1848 ((RangeObject
*)(self
))->end
,
1849 &((RangeObject
*)(self
))->end
);
1852 /* Buffer list object - Definitions
1861 static PySequenceMethods BufListAsSeq
= {
1862 (PyInquiry
) BufListLength
, /* sq_length, len(x) */
1863 (binaryfunc
) 0, /* sq_concat, x+y */
1864 (PyIntArgFunc
) 0, /* sq_repeat, x*n */
1865 (PyIntArgFunc
) BufListItem
, /* sq_item, x[i] */
1866 (PyIntIntArgFunc
) 0, /* sq_slice, x[i:j] */
1867 (PyIntObjArgProc
) 0, /* sq_ass_item, x[i]=v */
1868 (PyIntIntObjArgProc
) 0, /* sq_ass_slice, x[i:j]=v */
1871 static PyTypeObject BufListType
= {
1872 PyObject_HEAD_INIT(0)
1875 sizeof(BufListObject
),
1878 (destructor
) 0, /* tp_dealloc, refcount==0 */
1879 (printfunc
) 0, /* tp_print, print x */
1880 (getattrfunc
) 0, /* tp_getattr, x.attr */
1881 (setattrfunc
) 0, /* tp_setattr, x.attr=v */
1882 (cmpfunc
) 0, /* tp_compare, x>y */
1883 (reprfunc
) 0, /* tp_repr, `x`, print x */
1886 &BufListAsSeq
, /* as sequence */
1889 (hashfunc
) 0, /* tp_hash, dict(x) */
1890 (ternaryfunc
) 0, /* tp_call, x() */
1891 (reprfunc
) 0, /* tp_str, str(x) */
1894 /* Buffer list object - Implementation
1899 BufListLength(PyObject
*self
)
1901 buf_T
*b
= firstbuf
;
1915 BufListItem(PyObject
*self
, PyInt n
)
1919 for (b
= firstbuf
; b
; b
= b
->b_next
, --n
)
1922 return BufferNew(b
);
1925 PyErr_SetString(PyExc_IndexError
, _("no such buffer"));
1929 /* Window object - Definitions
1932 static struct PyMethodDef WindowMethods
[] = {
1933 /* name, function, calling, documentation */
1934 { NULL
, NULL
, 0, NULL
}
1937 static PyTypeObject WindowType
= {
1938 PyObject_HEAD_INIT(0)
1941 sizeof(WindowObject
),
1944 (destructor
) WindowDestructor
, /* tp_dealloc, refcount==0 */
1945 (printfunc
) 0, /* tp_print, print x */
1946 (getattrfunc
) WindowGetattr
, /* tp_getattr, x.attr */
1947 (setattrfunc
) WindowSetattr
, /* tp_setattr, x.attr=v */
1948 (cmpfunc
) 0, /* tp_compare, x>y */
1949 (reprfunc
) WindowRepr
, /* tp_repr, `x`, print x */
1952 0, /* as sequence */
1955 (hashfunc
) 0, /* tp_hash, dict(x) */
1956 (ternaryfunc
) 0, /* tp_call, x() */
1957 (reprfunc
) 0, /* tp_str, str(x) */
1960 /* Window object - Implementation
1964 WindowNew(win_T
*win
)
1966 /* We need to handle deletion of windows underneath us.
1967 * If we add a "w_python_ref" field to the win_T structure,
1968 * then we can get at it in win_free() in vim. We then
1969 * need to create only ONE Python object per window - if
1970 * we try to create a second, just INCREF the existing one
1971 * and return it. The (single) Python object referring to
1972 * the window is stored in "w_python_ref".
1973 * On a win_free() we set the Python object's win_T* field
1974 * to an invalid value. We trap all uses of a window
1975 * object, and reject them if the win_T* field is invalid.
1980 if (win
->w_python_ref
)
1982 self
= win
->w_python_ref
;
1987 self
= PyObject_NEW(WindowObject
, &WindowType
);
1991 win
->w_python_ref
= self
;
1994 return (PyObject
*)(self
);
1998 WindowDestructor(PyObject
*self
)
2000 WindowObject
*this = (WindowObject
*)(self
);
2002 if (this->win
&& this->win
!= INVALID_WINDOW_VALUE
)
2003 this->win
->w_python_ref
= NULL
;
2009 CheckWindow(WindowObject
*this)
2011 if (this->win
== INVALID_WINDOW_VALUE
)
2013 PyErr_SetVim(_("attempt to refer to deleted window"));
2021 WindowGetattr(PyObject
*self
, char *name
)
2023 WindowObject
*this = (WindowObject
*)(self
);
2025 if (CheckWindow(this))
2028 if (strcmp(name
, "buffer") == 0)
2029 return (PyObject
*)BufferNew(this->win
->w_buffer
);
2030 else if (strcmp(name
, "cursor") == 0)
2032 pos_T
*pos
= &this->win
->w_cursor
;
2034 return Py_BuildValue("(ll)", (long)(pos
->lnum
), (long)(pos
->col
));
2036 else if (strcmp(name
, "height") == 0)
2037 return Py_BuildValue("l", (long)(this->win
->w_height
));
2038 #ifdef FEAT_VERTSPLIT
2039 else if (strcmp(name
, "width") == 0)
2040 return Py_BuildValue("l", (long)(W_WIDTH(this->win
)));
2042 else if (strcmp(name
,"__members__") == 0)
2043 return Py_BuildValue("[sss]", "buffer", "cursor", "height");
2045 return Py_FindMethod(WindowMethods
, self
, name
);
2049 WindowSetattr(PyObject
*self
, char *name
, PyObject
*val
)
2051 WindowObject
*this = (WindowObject
*)(self
);
2053 if (CheckWindow(this))
2056 if (strcmp(name
, "buffer") == 0)
2058 PyErr_SetString(PyExc_TypeError
, _("readonly attribute"));
2061 else if (strcmp(name
, "cursor") == 0)
2066 if (!PyArg_Parse(val
, "(ll)", &lnum
, &col
))
2069 if (lnum
<= 0 || lnum
> this->win
->w_buffer
->b_ml
.ml_line_count
)
2071 PyErr_SetVim(_("cursor position outside buffer"));
2075 /* Check for keyboard interrupts */
2076 if (VimErrorCheck())
2079 /* NO CHECK ON COLUMN - SEEMS NOT TO MATTER */
2081 this->win
->w_cursor
.lnum
= lnum
;
2082 this->win
->w_cursor
.col
= col
;
2083 update_screen(VALID
);
2087 else if (strcmp(name
, "height") == 0)
2092 if (!PyArg_Parse(val
, "i", &height
))
2096 need_mouse_correct
= TRUE
;
2100 win_setheight(height
);
2103 /* Check for keyboard interrupts */
2104 if (VimErrorCheck())
2109 #ifdef FEAT_VERTSPLIT
2110 else if (strcmp(name
, "width") == 0)
2115 if (!PyArg_Parse(val
, "i", &width
))
2119 need_mouse_correct
= TRUE
;
2123 win_setwidth(width
);
2126 /* Check for keyboard interrupts */
2127 if (VimErrorCheck())
2135 PyErr_SetString(PyExc_AttributeError
, name
);
2141 WindowRepr(PyObject
*self
)
2143 static char repr
[100];
2144 WindowObject
*this = (WindowObject
*)(self
);
2146 if (this->win
== INVALID_WINDOW_VALUE
)
2148 vim_snprintf(repr
, 100, _("<window object (deleted) at %p>"), (self
));
2149 return PyString_FromString(repr
);
2156 for (w
= firstwin
; w
!= NULL
&& w
!= this->win
; w
= W_NEXT(w
))
2160 vim_snprintf(repr
, 100, _("<window object (unknown) at %p>"),
2163 vim_snprintf(repr
, 100, _("<window %d>"), i
);
2165 return PyString_FromString(repr
);
2169 /* Window list object - Definitions
2178 static PySequenceMethods WinListAsSeq
= {
2179 (PyInquiry
) WinListLength
, /* sq_length, len(x) */
2180 (binaryfunc
) 0, /* sq_concat, x+y */
2181 (PyIntArgFunc
) 0, /* sq_repeat, x*n */
2182 (PyIntArgFunc
) WinListItem
, /* sq_item, x[i] */
2183 (PyIntIntArgFunc
) 0, /* sq_slice, x[i:j] */
2184 (PyIntObjArgProc
) 0, /* sq_ass_item, x[i]=v */
2185 (PyIntIntObjArgProc
) 0, /* sq_ass_slice, x[i:j]=v */
2188 static PyTypeObject WinListType
= {
2189 PyObject_HEAD_INIT(0)
2192 sizeof(WinListObject
),
2195 (destructor
) 0, /* tp_dealloc, refcount==0 */
2196 (printfunc
) 0, /* tp_print, print x */
2197 (getattrfunc
) 0, /* tp_getattr, x.attr */
2198 (setattrfunc
) 0, /* tp_setattr, x.attr=v */
2199 (cmpfunc
) 0, /* tp_compare, x>y */
2200 (reprfunc
) 0, /* tp_repr, `x`, print x */
2203 &WinListAsSeq
, /* as sequence */
2206 (hashfunc
) 0, /* tp_hash, dict(x) */
2207 (ternaryfunc
) 0, /* tp_call, x() */
2208 (reprfunc
) 0, /* tp_str, str(x) */
2211 /* Window list object - Implementation
2215 WinListLength(PyObject
*self
)
2217 win_T
*w
= firstwin
;
2231 WinListItem(PyObject
*self
, PyInt n
)
2235 for (w
= firstwin
; w
!= NULL
; w
= W_NEXT(w
), --n
)
2237 return WindowNew(w
);
2239 PyErr_SetString(PyExc_IndexError
, _("no such window"));
2243 /* Current items object - Definitions
2252 static PyTypeObject CurrentType
= {
2253 PyObject_HEAD_INIT(0)
2256 sizeof(CurrentObject
),
2259 (destructor
) 0, /* tp_dealloc, refcount==0 */
2260 (printfunc
) 0, /* tp_print, print x */
2261 (getattrfunc
) CurrentGetattr
, /* tp_getattr, x.attr */
2262 (setattrfunc
) CurrentSetattr
, /* tp_setattr, x.attr=v */
2263 (cmpfunc
) 0, /* tp_compare, x>y */
2264 (reprfunc
) 0, /* tp_repr, `x`, print x */
2267 0, /* as sequence */
2270 (hashfunc
) 0, /* tp_hash, dict(x) */
2271 (ternaryfunc
) 0, /* tp_call, x() */
2272 (reprfunc
) 0, /* tp_str, str(x) */
2275 /* Current items object - Implementation
2279 CurrentGetattr(PyObject
*self
, char *name
)
2281 if (strcmp(name
, "buffer") == 0)
2282 return (PyObject
*)BufferNew(curbuf
);
2283 else if (strcmp(name
, "window") == 0)
2284 return (PyObject
*)WindowNew(curwin
);
2285 else if (strcmp(name
, "line") == 0)
2286 return GetBufferLine(curbuf
, (PyInt
)curwin
->w_cursor
.lnum
);
2287 else if (strcmp(name
, "range") == 0)
2288 return RangeNew(curbuf
, RangeStart
, RangeEnd
);
2289 else if (strcmp(name
,"__members__") == 0)
2290 return Py_BuildValue("[ssss]", "buffer", "window", "line", "range");
2293 PyErr_SetString(PyExc_AttributeError
, name
);
2300 CurrentSetattr(PyObject
*self
, char *name
, PyObject
*value
)
2302 if (strcmp(name
, "line") == 0)
2304 if (SetBufferLine(curbuf
, (PyInt
)curwin
->w_cursor
.lnum
, value
, NULL
) == FAIL
)
2311 PyErr_SetString(PyExc_AttributeError
, name
);
2316 /* External interface
2320 python_buffer_free(buf_T
*buf
)
2322 if (buf
->b_python_ref
!= NULL
)
2324 BufferObject
*bp
= buf
->b_python_ref
;
2325 bp
->buf
= INVALID_BUFFER_VALUE
;
2326 buf
->b_python_ref
= NULL
;
2330 #if defined(FEAT_WINDOWS) || defined(PROTO)
2332 python_window_free(win_T
*win
)
2334 if (win
->w_python_ref
!= NULL
)
2336 WindowObject
*wp
= win
->w_python_ref
;
2337 wp
->win
= INVALID_WINDOW_VALUE
;
2338 win
->w_python_ref
= NULL
;
2343 static BufListObject TheBufferList
=
2345 PyObject_HEAD_INIT(&BufListType
)
2348 static WinListObject TheWindowList
=
2350 PyObject_HEAD_INIT(&WinListType
)
2353 static CurrentObject TheCurrent
=
2355 PyObject_HEAD_INIT(&CurrentType
)
2359 PythonMod_Init(void)
2363 /* The special value is removed from sys.path in Python_Init(). */
2364 static char *(argv
[2]) = {"/must>not&exist/foo", NULL
};
2367 BufferType
.ob_type
= &PyType_Type
;
2368 RangeType
.ob_type
= &PyType_Type
;
2369 WindowType
.ob_type
= &PyType_Type
;
2370 BufListType
.ob_type
= &PyType_Type
;
2371 WinListType
.ob_type
= &PyType_Type
;
2372 CurrentType
.ob_type
= &PyType_Type
;
2374 /* Set sys.argv[] to avoid a crash in warn(). */
2375 PySys_SetArgv(1, argv
);
2377 mod
= Py_InitModule4("vim", VimMethods
, (char *)NULL
, (PyObject
*)NULL
, PYTHON_API_VERSION
);
2378 dict
= PyModule_GetDict(mod
);
2380 VimError
= Py_BuildValue("s", "vim.error");
2382 PyDict_SetItemString(dict
, "error", VimError
);
2383 PyDict_SetItemString(dict
, "buffers", (PyObject
*)(void *)&TheBufferList
);
2384 PyDict_SetItemString(dict
, "current", (PyObject
*)(void *)&TheCurrent
);
2385 PyDict_SetItemString(dict
, "windows", (PyObject
*)(void *)&TheWindowList
);
2387 if (PyErr_Occurred())
2393 /*************************************************************************
2394 * 4. Utility functions for handling the interface between Vim and Python.
2397 /* Get a line from the specified buffer. The line number is
2398 * in Vim format (1-based). The line is returned as a Python
2402 GetBufferLine(buf_T
*buf
, PyInt n
)
2404 return LineToString((char *)ml_get_buf(buf
, (linenr_T
)n
, FALSE
));
2407 /* Get a list of lines from the specified buffer. The line numbers
2408 * are in Vim format (1-based). The range is from lo up to, but not
2409 * including, hi. The list is returned as a Python list of string objects.
2412 GetBufferLineList(buf_T
*buf
, PyInt lo
, PyInt hi
)
2416 PyObject
*list
= PyList_New(n
);
2421 for (i
= 0; i
< n
; ++i
)
2423 PyObject
*str
= LineToString((char *)ml_get_buf(buf
, (linenr_T
)(lo
+i
), FALSE
));
2425 /* Error check - was the Python string creation OK? */
2432 /* Set the list item */
2433 if (PyList_SetItem(list
, i
, str
))
2441 /* The ownership of the Python list is passed to the caller (ie,
2442 * the caller should Py_DECREF() the object when it is finished
2450 * Check if deleting lines made the cursor position invalid.
2451 * Changed the lines from "lo" to "hi" and added "extra" lines (negative if
2455 py_fix_cursor(linenr_T lo
, linenr_T hi
, linenr_T extra
)
2457 if (curwin
->w_cursor
.lnum
>= lo
)
2459 /* Adjust the cursor position if it's in/after the changed
2461 if (curwin
->w_cursor
.lnum
>= hi
)
2463 curwin
->w_cursor
.lnum
+= extra
;
2468 curwin
->w_cursor
.lnum
= lo
;
2473 changed_cline_bef_curs();
2475 invalidate_botline();
2478 /* Replace a line in the specified buffer. The line number is
2479 * in Vim format (1-based). The replacement line is given as
2480 * a Python string object. The object is checked for validity
2481 * and correct format. Errors are returned as a value of FAIL.
2482 * The return value is OK on success.
2483 * If OK is returned and len_change is not NULL, *len_change
2484 * is set to the change in the buffer length.
2487 SetBufferLine(buf_T
*buf
, PyInt n
, PyObject
*line
, PyInt
*len_change
)
2489 /* First of all, we check the thpe of the supplied Python object.
2490 * There are three cases:
2491 * 1. NULL, or None - this is a deletion.
2492 * 2. A string - this is a replacement.
2493 * 3. Anything else - this is an error.
2495 if (line
== Py_None
|| line
== NULL
)
2497 buf_T
*savebuf
= curbuf
;
2502 if (u_savedel((linenr_T
)n
, 1L) == FAIL
)
2503 PyErr_SetVim(_("cannot save undo information"));
2504 else if (ml_delete((linenr_T
)n
, FALSE
) == FAIL
)
2505 PyErr_SetVim(_("cannot delete line"));
2508 deleted_lines_mark((linenr_T
)n
, 1L);
2509 if (buf
== curwin
->w_buffer
)
2510 py_fix_cursor((linenr_T
)n
, (linenr_T
)n
+ 1, (linenr_T
)-1);
2515 if (PyErr_Occurred() || VimErrorCheck())
2523 else if (PyString_Check(line
))
2525 char *save
= StringToLine(line
);
2526 buf_T
*savebuf
= curbuf
;
2531 /* We do not need to free "save" if ml_replace() consumes it. */
2535 if (u_savesub((linenr_T
)n
) == FAIL
)
2537 PyErr_SetVim(_("cannot save undo information"));
2540 else if (ml_replace((linenr_T
)n
, (char_u
*)save
, FALSE
) == FAIL
)
2542 PyErr_SetVim(_("cannot replace line"));
2546 changed_bytes((linenr_T
)n
, 0);
2550 /* Check that the cursor is not beyond the end of the line now. */
2551 if (buf
== curwin
->w_buffer
)
2554 if (PyErr_Occurred() || VimErrorCheck())
2564 PyErr_BadArgument();
2569 /* Replace a range of lines in the specified buffer. The line numbers are in
2570 * Vim format (1-based). The range is from lo up to, but not including, hi.
2571 * The replacement lines are given as a Python list of string objects. The
2572 * list is checked for validity and correct format. Errors are returned as a
2573 * value of FAIL. The return value is OK on success.
2574 * If OK is returned and len_change is not NULL, *len_change
2575 * is set to the change in the buffer length.
2578 SetBufferLineList(buf_T
*buf
, PyInt lo
, PyInt hi
, PyObject
*list
, PyInt
*len_change
)
2580 /* First of all, we check the thpe of the supplied Python object.
2581 * There are three cases:
2582 * 1. NULL, or None - this is a deletion.
2583 * 2. A list - this is a replacement.
2584 * 3. Anything else - this is an error.
2586 if (list
== Py_None
|| list
== NULL
)
2589 PyInt n
= (int)(hi
- lo
);
2590 buf_T
*savebuf
= curbuf
;
2595 if (u_savedel((linenr_T
)lo
, (long)n
) == FAIL
)
2596 PyErr_SetVim(_("cannot save undo information"));
2599 for (i
= 0; i
< n
; ++i
)
2601 if (ml_delete((linenr_T
)lo
, FALSE
) == FAIL
)
2603 PyErr_SetVim(_("cannot delete line"));
2607 deleted_lines_mark((linenr_T
)lo
, (long)i
);
2609 if (buf
== curwin
->w_buffer
)
2610 py_fix_cursor((linenr_T
)lo
, (linenr_T
)hi
, (linenr_T
)-n
);
2615 if (PyErr_Occurred() || VimErrorCheck())
2623 else if (PyList_Check(list
))
2626 PyInt new_len
= PyList_Size(list
);
2627 PyInt old_len
= hi
- lo
;
2628 PyInt extra
= 0; /* lines added to text, can be negative */
2632 if (new_len
== 0) /* avoid allocating zero bytes */
2636 array
= (char **)alloc((unsigned)(new_len
* sizeof(char *)));
2644 for (i
= 0; i
< new_len
; ++i
)
2646 PyObject
*line
= PyList_GetItem(list
, i
);
2648 array
[i
] = StringToLine(line
);
2649 if (array
[i
] == NULL
)
2652 vim_free(array
[--i
]);
2663 if (u_save((linenr_T
)(lo
-1), (linenr_T
)hi
) == FAIL
)
2664 PyErr_SetVim(_("cannot save undo information"));
2666 /* If the size of the range is reducing (ie, new_len < old_len) we
2667 * need to delete some old_len. We do this at the start, by
2668 * repeatedly deleting line "lo".
2670 if (!PyErr_Occurred())
2672 for (i
= 0; i
< old_len
- new_len
; ++i
)
2673 if (ml_delete((linenr_T
)lo
, FALSE
) == FAIL
)
2675 PyErr_SetVim(_("cannot delete line"));
2681 /* For as long as possible, replace the existing old_len with the
2682 * new old_len. This is a more efficient operation, as it requires
2683 * less memory allocation and freeing.
2685 if (!PyErr_Occurred())
2687 for (i
= 0; i
< old_len
&& i
< new_len
; ++i
)
2688 if (ml_replace((linenr_T
)(lo
+i
), (char_u
*)array
[i
], FALSE
)
2691 PyErr_SetVim(_("cannot replace line"));
2698 /* Now we may need to insert the remaining new old_len. If we do, we
2699 * must free the strings as we finish with them (we can't pass the
2700 * responsibility to vim in this case).
2702 if (!PyErr_Occurred())
2706 if (ml_append((linenr_T
)(lo
+ i
- 1),
2707 (char_u
*)array
[i
], 0, FALSE
) == FAIL
)
2709 PyErr_SetVim(_("cannot insert line"));
2718 /* Free any left-over old_len, as a result of an error */
2725 /* Free the array of old_len. All of its contents have now
2726 * been dealt with (either freed, or the responsibility passed
2731 /* Adjust marks. Invalidate any which lie in the
2732 * changed range, and move any in the remainder of the buffer.
2734 mark_adjust((linenr_T
)lo
, (linenr_T
)(hi
- 1),
2735 (long)MAXLNUM
, (long)extra
);
2736 changed_lines((linenr_T
)lo
, 0, (linenr_T
)hi
, (long)extra
);
2738 if (buf
== curwin
->w_buffer
)
2739 py_fix_cursor((linenr_T
)lo
, (linenr_T
)hi
, (linenr_T
)extra
);
2743 if (PyErr_Occurred() || VimErrorCheck())
2747 *len_change
= new_len
- old_len
;
2753 PyErr_BadArgument();
2758 /* Insert a number of lines into the specified buffer after the specifed line.
2759 * The line number is in Vim format (1-based). The lines to be inserted are
2760 * given as a Python list of string objects or as a single string. The lines
2761 * to be added are checked for validity and correct format. Errors are
2762 * returned as a value of FAIL. The return value is OK on success.
2763 * If OK is returned and len_change is not NULL, *len_change
2764 * is set to the change in the buffer length.
2767 InsertBufferLines(buf_T
*buf
, PyInt n
, PyObject
*lines
, PyInt
*len_change
)
2769 /* First of all, we check the type of the supplied Python object.
2770 * It must be a string or a list, or the call is in error.
2772 if (PyString_Check(lines
))
2774 char *str
= StringToLine(lines
);
2785 if (u_save((linenr_T
)n
, (linenr_T
)(n
+1)) == FAIL
)
2786 PyErr_SetVim(_("cannot save undo information"));
2787 else if (ml_append((linenr_T
)n
, (char_u
*)str
, 0, FALSE
) == FAIL
)
2788 PyErr_SetVim(_("cannot insert line"));
2790 appended_lines_mark((linenr_T
)n
, 1L);
2794 update_screen(VALID
);
2796 if (PyErr_Occurred() || VimErrorCheck())
2804 else if (PyList_Check(lines
))
2807 PyInt size
= PyList_Size(lines
);
2811 array
= (char **)alloc((unsigned)(size
* sizeof(char *)));
2818 for (i
= 0; i
< size
; ++i
)
2820 PyObject
*line
= PyList_GetItem(lines
, i
);
2821 array
[i
] = StringToLine(line
);
2823 if (array
[i
] == NULL
)
2826 vim_free(array
[--i
]);
2837 if (u_save((linenr_T
)n
, (linenr_T
)(n
+ 1)) == FAIL
)
2838 PyErr_SetVim(_("cannot save undo information"));
2841 for (i
= 0; i
< size
; ++i
)
2843 if (ml_append((linenr_T
)(n
+ i
),
2844 (char_u
*)array
[i
], 0, FALSE
) == FAIL
)
2846 PyErr_SetVim(_("cannot insert line"));
2848 /* Free the rest of the lines */
2850 vim_free(array
[i
++]);
2857 appended_lines_mark((linenr_T
)n
, (long)i
);
2860 /* Free the array of lines. All of its contents have now
2866 update_screen(VALID
);
2868 if (PyErr_Occurred() || VimErrorCheck())
2878 PyErr_BadArgument();
2883 /* Convert a Vim line into a Python string.
2884 * All internal newlines are replaced by null characters.
2886 * On errors, the Python exception data is set, and NULL is returned.
2889 LineToString(const char *str
)
2892 PyInt len
= strlen(str
);
2895 /* Allocate an Python string object, with uninitialised contents. We
2896 * must do it this way, so that we can modify the string in place
2897 * later. See the Python source, Objects/stringobject.c for details.
2899 result
= PyString_FromStringAndSize(NULL
, len
);
2903 p
= PyString_AsString(result
);
2919 /* Convert a Python string into a Vim line.
2921 * The result is in allocated memory. All internal nulls are replaced by
2922 * newline characters. It is an error for the string to contain newline
2925 * On errors, the Python exception data is set, and NULL is returned.
2928 StringToLine(PyObject
*obj
)
2936 if (obj
== NULL
|| !PyString_Check(obj
))
2938 PyErr_BadArgument();
2942 str
= PyString_AsString(obj
);
2943 len
= PyString_Size(obj
);
2946 * Error checking: String must not contain newlines, as we
2947 * are replacing a single line, and we must replace it with
2949 * A trailing newline is removed, so that append(f.readlines()) works.
2951 p
= memchr(str
, '\n', len
);
2954 if (p
== str
+ len
- 1)
2958 PyErr_SetVim(_("string cannot contain newlines"));
2963 /* Create a copy of the string, with internal nulls replaced by
2964 * newline characters, as is the vim convention.
2966 save
= (char *)alloc((unsigned)(len
+1));
2973 for (i
= 0; i
< len
; ++i
)
2986 /* Check to see whether a Vim error has been reported, or a keyboard
2987 * interrupt has been detected.
2994 PyErr_SetNone(PyExc_KeyboardInterrupt
);
2997 else if (did_emsg
&& !PyErr_Occurred())
2999 PyErr_SetNone(VimError
);
3007 /* Don't generate a prototype for the next function, it generates an error on
3008 * newer Python versions. */
3009 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */ && !defined(PROTO)
3012 Py_GetProgramName(void)
3016 #endif /* Python 1.4 */