?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[7.2.278] Using magic number in the folding code.
[vim_extended.git] / src / if_python.c
blobb9a12fa2128138b50c1112ec8975344aa5361622
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9 /*
10 * Python extensions by Paul Moore.
11 * Changes for Unix by David Leonard.
12 *
13 * This consists of four parts:
14 * 1. Python interpreter main program
15 * 2. Python output stream: writes output via [e]msg().
16 * 3. Implementation of the Vim module for Python
17 * 4. Utility functions for handling the interface between Vim and Python.
18 */
19
20 #include "vim.h"
21
22 #include <limits.h>
23
24 /* Python.h defines _POSIX_THREADS itself (if needed) */
25 #ifdef _POSIX_THREADS
26 # undef _POSIX_THREADS
27 #endif
28
29 #if defined(_WIN32) && defined (HAVE_FCNTL_H)
30 # undef HAVE_FCNTL_H
31 #endif
32
33 #ifdef _DEBUG
34 # undef _DEBUG
35 #endif
36
37 #ifdef HAVE_STDARG_H
38 # undef HAVE_STDARG_H /* Python's config.h defines it as well. */
39 #endif
40
41 #define PY_SSIZE_T_CLEAN
42
43 #include <Python.h>
44 #if defined(MACOS) && !defined(MACOS_X_UNIX)
45 # include "macglue.h"
46 # include <CodeFragments.h>
47 #endif
48 #undef main /* Defined in python.h - aargh */
49 #undef HAVE_FCNTL_H /* Clash with os_win32.h */
50
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
58 #endif
59
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"
68 #else
69 # define PyInt int
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"
76 #endif
77
78 /* Parser flags */
79 #define single_input 256
80 #define file_input 257
81 #define eval_input 258
82
83 #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x020300F0
84 /* Python 2.3: can invoke ":python" recursively. */
85 # define PY_CAN_RECURSE
86 #endif
87
88 #if defined(DYNAMIC_PYTHON) || defined(PROTO)
89 # ifndef DYNAMIC_PYTHON
90 # define HINSTANCE long_u /* for generating prototypes */
91 # endif
92
93 /* This makes if_python.c compile without warnings against Python 2.5
94 * on Win32 and Win64. */
95 #undef PyRun_SimpleString
96 #undef PyArg_Parse
97 #undef PyArg_ParseTuple
98 #undef Py_BuildValue
99 #undef Py_InitModule4
100 #undef Py_InitModule4_64
101
102 /*
103 * Wrapper defines
104 */
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
120 # endif
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
154 # endif
155 # if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02030000
156 # define PyObject_Malloc dll_PyObject_Malloc
157 # define PyObject_Free dll_PyObject_Free
158 # endif
159
160 /*
161 * Pointers for dynamic link
162 */
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);
178 #endif
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 *);
212 # endif
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*);
216 # endif
217
218 static HINSTANCE hinstPython = 0; /* Instance of python.dll */
219
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;
226
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
232
233 /*
234 * Table of name to function pointer of python.
235 */
236 # define PYTHON_PROC FARPROC
237 static struct
238 {
239 char *name;
240 PYTHON_PROC *ptr;
241 } python_funcname_table[] =
242 {
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},
258 # endif
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},
285 # else
286 {"Py_InitModule4", (PYTHON_PROC*)&dll_Py_InitModule4},
287 # endif
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},
296 # endif
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},
300 # endif
301 {"", NULL},
302 };
303
304 /*
305 * Free python.dll
306 */
307 static void
308 end_dynamic_python(void)
309 {
310 if (hinstPython)
311 {
312 FreeLibrary(hinstPython);
313 hinstPython = 0;
314 }
315 }
316
317 /*
318 * Load library and get all pointers.
319 * Parameter 'libname' provides name of DLL.
320 * Return OK or FAIL.
321 */
322 static int
323 python_runtime_link_init(char *libname, int verbose)
324 {
325 int i;
326
327 if (hinstPython)
328 return OK;
329 hinstPython = LoadLibrary(libname);
330 if (!hinstPython)
331 {
332 if (verbose)
333 EMSG2(_(e_loadlib), libname);
334 return FAIL;
335 }
336
337 for (i = 0; python_funcname_table[i].ptr; ++i)
338 {
339 if ((*python_funcname_table[i].ptr = GetProcAddress(hinstPython,
340 python_funcname_table[i].name)) == NULL)
341 {
342 FreeLibrary(hinstPython);
343 hinstPython = 0;
344 if (verbose)
345 EMSG2(_(e_loadfunc), python_funcname_table[i].name);
346 return FAIL;
347 }
348 }
349 return OK;
350 }
351
352 /*
353 * If python is enabled (there is installed python on Windows system) return
354 * TRUE, else FALSE.
355 */
356 int
357 python_enabled(int verbose)
358 {
359 return python_runtime_link_init(DYNAMIC_PYTHON_DLL, verbose) == OK;
360 }
361
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).
364 */
365 static void get_exceptions __ARGS((void));
366
367 static void
368 get_exceptions()
369 {
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);
382 Py_XDECREF(exmod);
383 }
384 #endif /* DYNAMIC_PYTHON */
385
386 /******************************************************
387 * Internal function prototypes.
388 */
389
390 static void DoPythonCommand(exarg_T *, const char *);
391 static PyInt RangeStart;
392 static PyInt RangeEnd;
393
394 static void PythonIO_Flush(void);
395 static int PythonIO_Init(void);
396 static int PythonMod_Init(void);
397
398 /* Utility functions for the vim/python interface
399 * ----------------------------------------------
400 */
401 static PyObject *GetBufferLine(buf_T *, PyInt);
402 static PyObject *GetBufferLineList(buf_T *, PyInt, PyInt);
403
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 *);
407
408 static PyObject *LineToString(const char *);
409 static char *StringToLine(PyObject *);
410
411 static int VimErrorCheck(void);
412
413 #define PyErr_SetVim(str) PyErr_SetString(VimError, str)
414
415 /******************************************************
416 * 1. Python interpreter main program.
417 */
418
419 static int initialised = 0;
420
421 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */
422 typedef PyObject PyThreadState;
423 #endif
424
425 #ifdef PY_CAN_RECURSE
426 static PyGILState_STATE pygilstate = PyGILState_UNLOCKED;
427 #else
428 static PyThreadState *saved_python_thread = NULL;
429 #endif
430
431 /*
432 * Suspend a thread of the Python interpreter, other threads are allowed to
433 * run.
434 */
435 static void
436 Python_SaveThread(void)
437 {
438 #ifdef PY_CAN_RECURSE
439 PyGILState_Release(pygilstate);
440 #else
441 saved_python_thread = PyEval_SaveThread();
442 #endif
443 }
444
445 /*
446 * Restore a thread of the Python interpreter, waits for other threads to
447 * block.
448 */
449 static void
450 Python_RestoreThread(void)
451 {
452 #ifdef PY_CAN_RECURSE
453 pygilstate = PyGILState_Ensure();
454 #else
455 PyEval_RestoreThread(saved_python_thread);
456 saved_python_thread = NULL;
457 #endif
458 }
459
460 /*
461 * obtain a lock on the Vim data structures
462 */
463 static void Python_Lock_Vim(void)
464 {
465 }
466
467 /*
468 * release a lock on the Vim data structures
469 */
470 static void Python_Release_Vim(void)
471 {
472 }
473
474 void
475 python_end()
476 {
477 static int recurse = 0;
478
479 /* If a crash occurs while doing this, don't try again. */
480 if (recurse != 0)
481 return;
482
483 ++recurse;
484
485 #ifdef DYNAMIC_PYTHON
486 if (hinstPython && Py_IsInitialized())
487 {
488 Python_RestoreThread(); /* enter python */
489 Py_Finalize();
490 }
491 end_dynamic_python();
492 #else
493 if (Py_IsInitialized())
494 {
495 Python_RestoreThread(); /* enter python */
496 Py_Finalize();
497 }
498 #endif
499
500 --recurse;
501 }
502
503 static int
504 Python_Init(void)
505 {
506 if (!initialised)
507 {
508 #ifdef DYNAMIC_PYTHON
509 if (!python_enabled(TRUE))
510 {
511 EMSG(_("E263: Sorry, this command is disabled, the Python library could not be loaded."));
512 goto fail;
513 }
514 #endif
515
516 #if !defined(MACOS) || defined(MACOS_X_UNIX)
517 Py_Initialize();
518 #else
519 PyMac_Initialize();
520 #endif
521 /* initialise threads */
522 PyEval_InitThreads();
523
524 #ifdef DYNAMIC_PYTHON
525 get_exceptions();
526 #endif
527
528 if (PythonIO_Init())
529 goto fail;
530
531 if (PythonMod_Init())
532 goto fail;
533
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)");
539
540 /* the first python thread is vim's, release the lock */
541 Python_SaveThread();
542
543 initialised = 1;
544 }
545
546 return 0;
547
548 fail:
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).
553 */
554 PythonIO_Flush();
555 return -1;
556 }
557
558 /*
559 * External interface
560 */
561 static void
562 DoPythonCommand(exarg_T *eap, const char *cmd)
563 {
564 #ifndef PY_CAN_RECURSE
565 static int recursive = 0;
566 #endif
567 #if defined(MACOS) && !defined(MACOS_X_UNIX)
568 GrafPtr oldPort;
569 #endif
570 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
571 char *saved_locale;
572 #endif
573
574 #ifndef PY_CAN_RECURSE
575 if (recursive)
576 {
577 EMSG(_("E659: Cannot invoke Python recursively"));
578 return;
579 }
580 ++recursive;
581 #endif
582
583 #if defined(MACOS) && !defined(MACOS_X_UNIX)
584 GetPort(&oldPort);
585 /* Check if the Python library is available */
586 if ((Ptr)PyMac_Initialize == (Ptr)kUnresolvedCFragSymbolAddress)
587 goto theend;
588 #endif
589 if (Python_Init())
590 goto theend;
591
592 RangeStart = eap->line1;
593 RangeEnd = eap->line2;
594 Python_Release_Vim(); /* leave vim */
595
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)
600 saved_locale = NULL;
601 else
602 {
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");
606 }
607 #endif
608
609 Python_RestoreThread(); /* enter python */
610
611 PyRun_SimpleString((char *)(cmd));
612
613 Python_SaveThread(); /* leave python */
614
615 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
616 if (saved_locale != NULL)
617 {
618 (void)setlocale(LC_NUMERIC, saved_locale);
619 vim_free(saved_locale);
620 }
621 #endif
622
623 Python_Lock_Vim(); /* enter vim */
624 PythonIO_Flush();
625 #if defined(MACOS) && !defined(MACOS_X_UNIX)
626 SetPort(oldPort);
627 #endif
628
629 theend:
630 #ifndef PY_CAN_RECURSE
631 --recursive;
632 #endif
633 return; /* keeps lint happy */
634 }
635
636 /*
637 * ":python"
638 */
639 void
640 ex_python(exarg_T *eap)
641 {
642 char_u *script;
643
644 script = script_get(eap, eap->arg);
645 if (!eap->skip)
646 {
647 if (script == NULL)
648 DoPythonCommand(eap, (char *)eap->arg);
649 else
650 DoPythonCommand(eap, (char *)script);
651 }
652 vim_free(script);
653 }
654
655 #define BUFFER_SIZE 1024
656
657 /*
658 * ":pyfile"
659 */
660 void
661 ex_pyfile(exarg_T *eap)
662 {
663 static char buffer[BUFFER_SIZE];
664 const char *file = (char *)eap->arg;
665 char *p;
666
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.
671 *
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.
675 */
676 strcpy(buffer, "execfile('");
677 p = buffer + 10; /* size of "execfile('" */
678
679 while (*file && p < buffer + (BUFFER_SIZE - 3))
680 {
681 if (*file == '\\' || *file == '\'')
682 *p++ = '\\';
683 *p++ = *file++;
684 }
685
686 /* If we didn't finish the file name, we hit a buffer overflow */
687 if (*file != '\0')
688 return;
689
690 /* Put in the terminating "')" and a null */
691 *p++ = '\'';
692 *p++ = ')';
693 *p++ = '\0';
694
695 /* Execute the file */
696 DoPythonCommand(eap, buffer);
697 }
698
699 /******************************************************
700 * 2. Python output stream: writes output via [e]msg().
701 */
702
703 /* Implementation functions
704 */
705
706 static PyObject *OutputGetattr(PyObject *, char *);
707 static int OutputSetattr(PyObject *, char *, PyObject *);
708
709 static PyObject *OutputWrite(PyObject *, PyObject *);
710 static PyObject *OutputWritelines(PyObject *, PyObject *);
711
712 typedef void (*writefn)(char_u *);
713 static void writer(writefn fn, char_u *str, PyInt n);
714
715 /* Output object definition
716 */
717
718 typedef struct
719 {
720 PyObject_HEAD
721 long softspace;
722 long error;
723 } OutputObject;
724
725 static struct PyMethodDef OutputMethods[] = {
726 /* name, function, calling, documentation */
727 {"write", OutputWrite, 1, "" },
728 {"writelines", OutputWritelines, 1, "" },
729 { NULL, NULL, 0, NULL }
730 };
731
732 static PyTypeObject OutputType = {
733 PyObject_HEAD_INIT(0)
734 0,
735 "message",
736 sizeof(OutputObject),
737 0,
738
739 (destructor) 0,
740 (printfunc) 0,
741 (getattrfunc) OutputGetattr,
742 (setattrfunc) OutputSetattr,
743 (cmpfunc) 0,
744 (reprfunc) 0,
745
746 0, /* as number */
747 0, /* as sequence */
748 0, /* as mapping */
749
750 (hashfunc) 0,
751 (ternaryfunc) 0,
752 (reprfunc) 0
753 };
754
755 /*************/
756
757 static PyObject *
758 OutputGetattr(PyObject *self, char *name)
759 {
760 if (strcmp(name, "softspace") == 0)
761 return PyInt_FromLong(((OutputObject *)(self))->softspace);
762
763 return Py_FindMethod(OutputMethods, self, name);
764 }
765
766 static int
767 OutputSetattr(PyObject *self, char *name, PyObject *val)
768 {
769 if (val == NULL) {
770 PyErr_SetString(PyExc_AttributeError, _("can't delete OutputObject attributes"));
771 return -1;
772 }
773
774 if (strcmp(name, "softspace") == 0)
775 {
776 if (!PyInt_Check(val)) {
777 PyErr_SetString(PyExc_TypeError, _("softspace must be an integer"));
778 return -1;
779 }
780
781 ((OutputObject *)(self))->softspace = PyInt_AsLong(val);
782 return 0;
783 }
784
785 PyErr_SetString(PyExc_AttributeError, _("invalid attribute"));
786 return -1;
787 }
788
789 /*************/
790
791 static PyObject *
792 OutputWrite(PyObject *self, PyObject *args)
793 {
794 int len;
795 char *str;
796 int error = ((OutputObject *)(self))->error;
797
798 if (!PyArg_ParseTuple(args, "s#", &str, &len))
799 return NULL;
800
801 Py_BEGIN_ALLOW_THREADS
802 Python_Lock_Vim();
803 writer((writefn)(error ? emsg : msg), (char_u *)str, len);
804 Python_Release_Vim();
805 Py_END_ALLOW_THREADS
806
807 Py_INCREF(Py_None);
808 return Py_None;
809 }
810
811 static PyObject *
812 OutputWritelines(PyObject *self, PyObject *args)
813 {
814 PyInt n;
815 PyInt i;
816 PyObject *list;
817 int error = ((OutputObject *)(self))->error;
818
819 if (!PyArg_ParseTuple(args, "O", &list))
820 return NULL;
821 Py_INCREF(list);
822
823 if (!PyList_Check(list)) {
824 PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
825 Py_DECREF(list);
826 return NULL;
827 }
828
829 n = PyList_Size(list);
830
831 for (i = 0; i < n; ++i)
832 {
833 PyObject *line = PyList_GetItem(list, i);
834 char *str;
835 PyInt len;
836
837 if (!PyArg_Parse(line, "s#", &str, &len)) {
838 PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
839 Py_DECREF(list);
840 return NULL;
841 }
842
843 Py_BEGIN_ALLOW_THREADS
844 Python_Lock_Vim();
845 writer((writefn)(error ? emsg : msg), (char_u *)str, len);
846 Python_Release_Vim();
847 Py_END_ALLOW_THREADS
848 }
849
850 Py_DECREF(list);
851 Py_INCREF(Py_None);
852 return Py_None;
853 }
854
855 /* Output buffer management
856 */
857
858 static char_u *buffer = NULL;
859 static PyInt buffer_len = 0;
860 static PyInt buffer_size = 0;
861
862 static writefn old_fn = NULL;
863
864 static void
865 buffer_ensure(PyInt n)
866 {
867 PyInt new_size;
868 char_u *new_buffer;
869
870 if (n < buffer_size)
871 return;
872
873 new_size = buffer_size;
874 while (new_size < n)
875 new_size += 80;
876
877 if (new_size != buffer_size)
878 {
879 new_buffer = alloc((unsigned)new_size);
880 if (new_buffer == NULL)
881 return;
882
883 if (buffer)
884 {
885 memcpy(new_buffer, buffer, buffer_len);
886 vim_free(buffer);
887 }
888
889 buffer = new_buffer;
890 buffer_size = new_size;
891 }
892 }
893
894 static void
895 PythonIO_Flush(void)
896 {
897 if (old_fn && buffer_len)
898 {
899 buffer[buffer_len] = 0;
900 old_fn(buffer);
901 }
902
903 buffer_len = 0;
904 }
905
906 static void
907 writer(writefn fn, char_u *str, PyInt n)
908 {
909 char_u *ptr;
910
911 if (fn != old_fn && old_fn != NULL)
912 PythonIO_Flush();
913
914 old_fn = fn;
915
916 while (n > 0 && (ptr = memchr(str, '\n', n)) != NULL)
917 {
918 PyInt len = ptr - str;
919
920 buffer_ensure(buffer_len + len + 1);
921
922 memcpy(buffer + buffer_len, str, len);
923 buffer_len += len;
924 buffer[buffer_len] = 0;
925 fn(buffer);
926 str = ptr + 1;
927 n -= len + 1;
928 buffer_len = 0;
929 }
930
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);
934 buffer_len += n;
935 }
936
937 /***************/
938
939 static OutputObject Output =
940 {
941 PyObject_HEAD_INIT(&OutputType)
942 0,
943 0
944 };
945
946 static OutputObject Error =
947 {
948 PyObject_HEAD_INIT(&OutputType)
949 0,
950 1
951 };
952
953 static int
954 PythonIO_Init(void)
955 {
956 /* Fixups... */
957 OutputType.ob_type = &PyType_Type;
958
959 PySys_SetObject("stdout", (PyObject *)(void *)&Output);
960 PySys_SetObject("stderr", (PyObject *)(void *)&Error);
961
962 if (PyErr_Occurred())
963 {
964 EMSG(_("E264: Python: Error initialising I/O objects"));
965 return -1;
966 }
967
968 return 0;
969 }
970
971 /******************************************************
972 * 3. Implementation of the Vim module for Python
973 */
974
975 /* Vim module - Implementation functions
976 * -------------------------------------
977 */
978
979 static PyObject *VimError;
980
981 static PyObject *VimCommand(PyObject *, PyObject *);
982 static PyObject *VimEval(PyObject *, PyObject *);
983
984 /* Window type - Implementation functions
985 * --------------------------------------
986 */
987
988 typedef struct
989 {
990 PyObject_HEAD
991 win_T *win;
992 }
993 WindowObject;
994
995 #define INVALID_WINDOW_VALUE ((win_T *)(-1))
996
997 #define WindowType_Check(obj) ((obj)->ob_type == &WindowType)
998
999 static PyObject *WindowNew(win_T *);
1000
1001 static void WindowDestructor(PyObject *);
1002 static PyObject *WindowGetattr(PyObject *, char *);
1003 static int WindowSetattr(PyObject *, char *, PyObject *);
1004 static PyObject *WindowRepr(PyObject *);
1005
1006 /* Buffer type - Implementation functions
1007 * --------------------------------------
1008 */
1009
1010 typedef struct
1011 {
1012 PyObject_HEAD
1013 buf_T *buf;
1014 }
1015 BufferObject;
1016
1017 #define INVALID_BUFFER_VALUE ((buf_T *)(-1))
1018
1019 #define BufferType_Check(obj) ((obj)->ob_type == &BufferType)
1020
1021 static PyObject *BufferNew (buf_T *);
1022
1023 static void BufferDestructor(PyObject *);
1024 static PyObject *BufferGetattr(PyObject *, char *);
1025 static PyObject *BufferRepr(PyObject *);
1026
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 *);
1032
1033 static PyObject *BufferAppend(PyObject *, PyObject *);
1034 static PyObject *BufferMark(PyObject *, PyObject *);
1035 static PyObject *BufferRange(PyObject *, PyObject *);
1036
1037 /* Line range type - Implementation functions
1038 * --------------------------------------
1039 */
1040
1041 typedef struct
1042 {
1043 PyObject_HEAD
1044 BufferObject *buf;
1045 PyInt start;
1046 PyInt end;
1047 }
1048 RangeObject;
1049
1050 #define RangeType_Check(obj) ((obj)->ob_type == &RangeType)
1051
1052 static PyObject *RangeNew(buf_T *, PyInt, PyInt);
1053
1054 static void RangeDestructor(PyObject *);
1055 static PyObject *RangeGetattr(PyObject *, char *);
1056 static PyObject *RangeRepr(PyObject *);
1057
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 *);
1063
1064 static PyObject *RangeAppend(PyObject *, PyObject *);
1065
1066 /* Window list type - Implementation functions
1067 * -------------------------------------------
1068 */
1069
1070 static PyInt WinListLength(PyObject *);
1071 static PyObject *WinListItem(PyObject *, PyInt);
1072
1073 /* Buffer list type - Implementation functions
1074 * -------------------------------------------
1075 */
1076
1077 static PyInt BufListLength(PyObject *);
1078 static PyObject *BufListItem(PyObject *, PyInt);
1079
1080 /* Current objects type - Implementation functions
1081 * -----------------------------------------------
1082 */
1083
1084 static PyObject *CurrentGetattr(PyObject *, char *);
1085 static int CurrentSetattr(PyObject *, char *, PyObject *);
1086
1087 /* Vim module - Definitions
1088 */
1089
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 }
1095 };
1096
1097 /* Vim module - Implementation
1098 */
1099 static PyObject *
1100 VimCommand(PyObject *self UNUSED, PyObject *args)
1101 {
1102 char *cmd;
1103 PyObject *result;
1104
1105 if (!PyArg_ParseTuple(args, "s", &cmd))
1106 return NULL;
1107
1108 PyErr_Clear();
1109
1110 Py_BEGIN_ALLOW_THREADS
1111 Python_Lock_Vim();
1112
1113 do_cmdline_cmd((char_u *)cmd);
1114 update_screen(VALID);
1115
1116 Python_Release_Vim();
1117 Py_END_ALLOW_THREADS
1118
1119 if (VimErrorCheck())
1120 result = NULL;
1121 else
1122 result = Py_None;
1123
1124 Py_XINCREF(result);
1125 return result;
1126 }
1127
1128 #ifdef FEAT_EVAL
1129 /*
1130 * Function to translate a typval_T into a PyObject; this will recursively
1131 * translate lists/dictionaries into their Python equivalents.
1132 *
1133 * The depth parameter is to avoid infinite recursion, set it to 1 when
1134 * you call VimToPython.
1135 */
1136 static PyObject *
1137 VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
1138 {
1139 PyObject *result;
1140 PyObject *newObj;
1141 char ptrBuf[NUMBUFLEN];
1142
1143 /* Avoid infinite recursion */
1144 if (depth > 100)
1145 {
1146 Py_INCREF(Py_None);
1147 result = Py_None;
1148 return result;
1149 }
1150
1151 /* Check if we run into a recursive loop. The item must be in lookupDict
1152 * then and we can use it again. */
1153 if ((our_tv->v_type == VAR_LIST && our_tv->vval.v_list != NULL)
1154 || (our_tv->v_type == VAR_DICT && our_tv->vval.v_dict != NULL))
1155 {
1156 sprintf(ptrBuf, PRINTF_DECIMAL_LONG_U,
1157 our_tv->v_type == VAR_LIST ? (long_u)our_tv->vval.v_list
1158 : (long_u)our_tv->vval.v_dict);
1159 result = PyDict_GetItemString(lookupDict, ptrBuf);
1160 if (result != NULL)
1161 {
1162 Py_INCREF(result);
1163 return result;
1164 }
1165 }
1166
1167 if (our_tv->v_type == VAR_STRING)
1168 {
1169 result = Py_BuildValue("s", our_tv->vval.v_string);
1170 }
1171 else if (our_tv->v_type == VAR_NUMBER)
1172 {
1173 char buf[NUMBUFLEN];
1174
1175 /* For backwards compatibility numbers are stored as strings. */
1176 sprintf(buf, "%ld", (long)our_tv->vval.v_number);
1177 result = Py_BuildValue("s", buf);
1178 }
1179 # ifdef FEAT_FLOAT
1180 else if (our_tv->v_type == VAR_FLOAT)
1181 {
1182 char buf[NUMBUFLEN];
1183
1184 sprintf(buf, "%f", our_tv->vval.v_float);
1185 result = Py_BuildValue("s", buf);
1186 }
1187 # endif
1188 else if (our_tv->v_type == VAR_LIST)
1189 {
1190 list_T *list = our_tv->vval.v_list;
1191 listitem_T *curr;
1192
1193 result = PyList_New(0);
1194
1195 if (list != NULL)
1196 {
1197 PyDict_SetItemString(lookupDict, ptrBuf, result);
1198
1199 for (curr = list->lv_first; curr != NULL; curr = curr->li_next)
1200 {
1201 newObj = VimToPython(&curr->li_tv, depth + 1, lookupDict);
1202 PyList_Append(result, newObj);
1203 Py_DECREF(newObj);
1204 }
1205 }
1206 }
1207 else if (our_tv->v_type == VAR_DICT)
1208 {
1209 result = PyDict_New();
1210
1211 if (our_tv->vval.v_dict != NULL)
1212 {
1213 hashtab_T *ht = &our_tv->vval.v_dict->dv_hashtab;
1214 long_u todo = ht->ht_used;
1215 hashitem_T *hi;
1216 dictitem_T *di;
1217
1218 PyDict_SetItemString(lookupDict, ptrBuf, result);
1219
1220 for (hi = ht->ht_array; todo > 0; ++hi)
1221 {
1222 if (!HASHITEM_EMPTY(hi))
1223 {
1224 --todo;
1225
1226 di = dict_lookup(hi);
1227 newObj = VimToPython(&di->di_tv, depth + 1, lookupDict);
1228 PyDict_SetItemString(result, (char *)hi->hi_key, newObj);
1229 Py_DECREF(newObj);
1230 }
1231 }
1232 }
1233 }
1234 else
1235 {
1236 Py_INCREF(Py_None);
1237 result = Py_None;
1238 }
1239
1240 return result;
1241 }
1242 #endif
1243
1244 static PyObject *
1245 VimEval(PyObject *self UNUSED, PyObject *args)
1246 {
1247 #ifdef FEAT_EVAL
1248 char *expr;
1249 typval_T *our_tv;
1250 PyObject *result;
1251 PyObject *lookup_dict;
1252
1253 if (!PyArg_ParseTuple(args, "s", &expr))
1254 return NULL;
1255
1256 Py_BEGIN_ALLOW_THREADS
1257 Python_Lock_Vim();
1258 our_tv = eval_expr((char_u *)expr, NULL);
1259
1260 Python_Release_Vim();
1261 Py_END_ALLOW_THREADS
1262
1263 if (our_tv == NULL)
1264 {
1265 PyErr_SetVim(_("invalid expression"));
1266 return NULL;
1267 }
1268
1269 /* Convert the Vim type into a Python type. Create a dictionary that's
1270 * used to check for recursive loops. */
1271 lookup_dict = PyDict_New();
1272 result = VimToPython(our_tv, 1, lookup_dict);
1273 Py_DECREF(lookup_dict);
1274
1275
1276 Py_BEGIN_ALLOW_THREADS
1277 Python_Lock_Vim();
1278 free_tv(our_tv);
1279 Python_Release_Vim();
1280 Py_END_ALLOW_THREADS
1281
1282 return result;
1283 #else
1284 PyErr_SetVim(_("expressions disabled at compile time"));
1285 return NULL;
1286 #endif
1287 }
1288
1289 /* Common routines for buffers and line ranges
1290 * -------------------------------------------
1291 */
1292 static int
1293 CheckBuffer(BufferObject *this)
1294 {
1295 if (this->buf == INVALID_BUFFER_VALUE)
1296 {
1297 PyErr_SetVim(_("attempt to refer to deleted buffer"));
1298 return -1;
1299 }
1300
1301 return 0;
1302 }
1303
1304 static PyObject *
1305 RBItem(BufferObject *self, PyInt n, PyInt start, PyInt end)
1306 {
1307 if (CheckBuffer(self))
1308 return NULL;
1309
1310 if (n < 0 || n > end - start)
1311 {
1312 PyErr_SetString(PyExc_IndexError, _("line number out of range"));
1313 return NULL;
1314 }
1315
1316 return GetBufferLine(self->buf, n+start);
1317 }
1318
1319 static PyObject *
1320 RBSlice(BufferObject *self, PyInt lo, PyInt hi, PyInt start, PyInt end)
1321 {
1322 PyInt size;
1323
1324 if (CheckBuffer(self))
1325 return NULL;
1326
1327 size = end - start + 1;
1328
1329 if (lo < 0)
1330 lo = 0;
1331 else if (lo > size)
1332 lo = size;
1333 if (hi < 0)
1334 hi = 0;
1335 if (hi < lo)
1336 hi = lo;
1337 else if (hi > size)
1338 hi = size;
1339
1340 return GetBufferLineList(self->buf, lo+start, hi+start);
1341 }
1342
1343 static PyInt
1344 RBAssItem(BufferObject *self, PyInt n, PyObject *val, PyInt start, PyInt end, PyInt *new_end)
1345 {
1346 PyInt len_change;
1347
1348 if (CheckBuffer(self))
1349 return -1;
1350
1351 if (n < 0 || n > end - start)
1352 {
1353 PyErr_SetString(PyExc_IndexError, _("line number out of range"));
1354 return -1;
1355 }
1356
1357 if (SetBufferLine(self->buf, n+start, val, &len_change) == FAIL)
1358 return -1;
1359
1360 if (new_end)
1361 *new_end = end + len_change;
1362
1363 return 0;
1364 }
1365
1366 static PyInt
1367 RBAssSlice(BufferObject *self, PyInt lo, PyInt hi, PyObject *val, PyInt start, PyInt end, PyInt *new_end)
1368 {
1369 PyInt size;
1370 PyInt len_change;
1371
1372 /* Self must be a valid buffer */
1373 if (CheckBuffer(self))
1374 return -1;
1375
1376 /* Sort out the slice range */
1377 size = end - start + 1;
1378
1379 if (lo < 0)
1380 lo = 0;
1381 else if (lo > size)
1382 lo = size;
1383 if (hi < 0)
1384 hi = 0;
1385 if (hi < lo)
1386 hi = lo;
1387 else if (hi > size)
1388 hi = size;
1389
1390 if (SetBufferLineList(self->buf, lo+start, hi+start, val, &len_change) == FAIL)
1391 return -1;
1392
1393 if (new_end)
1394 *new_end = end + len_change;
1395
1396 return 0;
1397 }
1398
1399 static PyObject *
1400 RBAppend(BufferObject *self, PyObject *args, PyInt start, PyInt end, PyInt *new_end)
1401 {
1402 PyObject *lines;
1403 PyInt len_change;
1404 PyInt max;
1405 PyInt n;
1406
1407 if (CheckBuffer(self))
1408 return NULL;
1409
1410 max = n = end - start + 1;
1411
1412 if (!PyArg_ParseTuple(args, "O|" Py_ssize_t_fmt, &lines, &n))
1413 return NULL;
1414
1415 if (n < 0 || n > max)
1416 {
1417 PyErr_SetString(PyExc_ValueError, _("line number out of range"));
1418 return NULL;
1419 }
1420
1421 if (InsertBufferLines(self->buf, n + start - 1, lines, &len_change) == FAIL)
1422 return NULL;
1423
1424 if (new_end)
1425 *new_end = end + len_change;
1426
1427 Py_INCREF(Py_None);
1428 return Py_None;
1429 }
1430
1431
1432 /* Buffer object - Definitions
1433 */
1434
1435 static struct PyMethodDef BufferMethods[] = {
1436 /* name, function, calling, documentation */
1437 {"append", BufferAppend, 1, "Append data to Vim buffer" },
1438 {"mark", BufferMark, 1, "Return (row,col) representing position of named mark" },
1439 {"range", BufferRange, 1, "Return a range object which represents the part of the given buffer between line numbers s and e" },
1440 { NULL, NULL, 0, NULL }
1441 };
1442
1443 static PySequenceMethods BufferAsSeq = {
1444 (PyInquiry) BufferLength, /* sq_length, len(x) */
1445 (binaryfunc) 0, /* BufferConcat, */ /* sq_concat, x+y */
1446 (PyIntArgFunc) 0, /* BufferRepeat, */ /* sq_repeat, x*n */
1447 (PyIntArgFunc) BufferItem, /* sq_item, x[i] */
1448 (PyIntIntArgFunc) BufferSlice, /* sq_slice, x[i:j] */
1449 (PyIntObjArgProc) BufferAssItem, /* sq_ass_item, x[i]=v */
1450 (PyIntIntObjArgProc) BufferAssSlice, /* sq_ass_slice, x[i:j]=v */
1451 };
1452
1453 static PyTypeObject BufferType = {
1454 PyObject_HEAD_INIT(0)
1455 0,
1456 "buffer",
1457 sizeof(BufferObject),
1458 0,
1459
1460 (destructor) BufferDestructor, /* tp_dealloc, refcount==0 */
1461 (printfunc) 0, /* tp_print, print x */
1462 (getattrfunc) BufferGetattr, /* tp_getattr, x.attr */
1463 (setattrfunc) 0, /* tp_setattr, x.attr=v */
1464 (cmpfunc) 0, /* tp_compare, x>y */
1465 (reprfunc) BufferRepr, /* tp_repr, `x`, print x */
1466
1467 0, /* as number */
1468 &BufferAsSeq, /* as sequence */
1469 0, /* as mapping */
1470
1471 (hashfunc) 0, /* tp_hash, dict(x) */
1472 (ternaryfunc) 0, /* tp_call, x() */
1473 (reprfunc) 0, /* tp_str, str(x) */
1474 };
1475
1476 /* Buffer object - Implementation
1477 */
1478
1479 static PyObject *
1480 BufferNew(buf_T *buf)
1481 {
1482 /* We need to handle deletion of buffers underneath us.
1483 * If we add a "b_python_ref" field to the buf_T structure,
1484 * then we can get at it in buf_freeall() in vim. We then
1485 * need to create only ONE Python object per buffer - if
1486 * we try to create a second, just INCREF the existing one
1487 * and return it. The (single) Python object referring to
1488 * the buffer is stored in "b_python_ref".
1489 * Question: what to do on a buf_freeall(). We'll probably
1490 * have to either delete the Python object (DECREF it to
1491 * zero - a bad idea, as it leaves dangling refs!) or
1492 * set the buf_T * value to an invalid value (-1?), which
1493 * means we need checks in all access functions... Bah.
1494 */
1495
1496 BufferObject *self;
1497
1498 if (buf->b_python_ref != NULL)
1499 {
1500 self = buf->b_python_ref;
1501 Py_INCREF(self);
1502 }
1503 else
1504 {
1505 self = PyObject_NEW(BufferObject, &BufferType);
1506 if (self == NULL)
1507 return NULL;
1508 self->buf = buf;
1509 buf->b_python_ref = self;
1510 }
1511
1512 return (PyObject *)(self);
1513 }
1514
1515 static void
1516 BufferDestructor(PyObject *self)
1517 {
1518 BufferObject *this = (BufferObject *)(self);
1519
1520 if (this->buf && this->buf != INVALID_BUFFER_VALUE)
1521 this->buf->b_python_ref = NULL;
1522
1523 Py_DECREF(self);
1524 }
1525
1526 static PyObject *
1527 BufferGetattr(PyObject *self, char *name)
1528 {
1529 BufferObject *this = (BufferObject *)(self);
1530
1531 if (CheckBuffer(this))
1532 return NULL;
1533
1534 if (strcmp(name, "name") == 0)
1535 return Py_BuildValue("s", this->buf->b_ffname);
1536 else if (strcmp(name, "number") == 0)
1537 return Py_BuildValue(Py_ssize_t_fmt, this->buf->b_fnum);
1538 else if (strcmp(name,"__members__") == 0)
1539 return Py_BuildValue("[ss]", "name", "number");
1540 else
1541 return Py_FindMethod(BufferMethods, self, name);
1542 }
1543
1544 static PyObject *
1545 BufferRepr(PyObject *self)
1546 {
1547 static char repr[100];
1548 BufferObject *this = (BufferObject *)(self);
1549
1550 if (this->buf == INVALID_BUFFER_VALUE)
1551 {
1552 vim_snprintf(repr, 100, _("<buffer object (deleted) at %p>"), (self));
1553 return PyString_FromString(repr);
1554 }
1555 else
1556 {
1557 char *name = (char *)this->buf->b_fname;
1558 PyInt len;
1559
1560 if (name == NULL)
1561 name = "";
1562 len = strlen(name);
1563
1564 if (len > 35)
1565 name = name + (35 - len);
1566
1567 vim_snprintf(repr, 100, "<buffer %s%s>", len > 35 ? "..." : "", name);
1568
1569 return PyString_FromString(repr);
1570 }
1571 }
1572
1573 /******************/
1574
1575 static PyInt
1576 BufferLength(PyObject *self)
1577 {
1578 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
1579 if (CheckBuffer((BufferObject *)(self)))
1580 return -1; /* ??? */
1581
1582 return (((BufferObject *)(self))->buf->b_ml.ml_line_count);
1583 }
1584
1585 static PyObject *
1586 BufferItem(PyObject *self, PyInt n)
1587 {
1588 return RBItem((BufferObject *)(self), n, 1,
1589 (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);
1590 }
1591
1592 static PyObject *
1593 BufferSlice(PyObject *self, PyInt lo, PyInt hi)
1594 {
1595 return RBSlice((BufferObject *)(self), lo, hi, 1,
1596 (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);
1597 }
1598
1599 static PyInt
1600 BufferAssItem(PyObject *self, PyInt n, PyObject *val)
1601 {
1602 return RBAssItem((BufferObject *)(self), n, val, 1,
1603 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1604 NULL);
1605 }
1606
1607 static PyInt
1608 BufferAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
1609 {
1610 return RBAssSlice((BufferObject *)(self), lo, hi, val, 1,
1611 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1612 NULL);
1613 }
1614
1615 static PyObject *
1616 BufferAppend(PyObject *self, PyObject *args)
1617 {
1618 return RBAppend((BufferObject *)(self), args, 1,
1619 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1620 NULL);
1621 }
1622
1623 static PyObject *
1624 BufferMark(PyObject *self, PyObject *args)
1625 {
1626 pos_T *posp;
1627 char mark;
1628 buf_T *curbuf_save;
1629
1630 if (CheckBuffer((BufferObject *)(self)))
1631 return NULL;
1632
1633 if (!PyArg_ParseTuple(args, "c", &mark))
1634 return NULL;
1635
1636 curbuf_save = curbuf;
1637 curbuf = ((BufferObject *)(self))->buf;
1638 posp = getmark(mark, FALSE);
1639 curbuf = curbuf_save;
1640
1641 if (posp == NULL)
1642 {
1643 PyErr_SetVim(_("invalid mark name"));
1644 return NULL;
1645 }
1646
1647 /* Ckeck for keyboard interrupt */
1648 if (VimErrorCheck())
1649 return NULL;
1650
1651 if (posp->lnum <= 0)
1652 {
1653 /* Or raise an error? */
1654 Py_INCREF(Py_None);
1655 return Py_None;
1656 }
1657
1658 return Py_BuildValue("(ll)", (long)(posp->lnum), (long)(posp->col));
1659 }
1660
1661 static PyObject *
1662 BufferRange(PyObject *self, PyObject *args)
1663 {
1664 PyInt start;
1665 PyInt end;
1666
1667 if (CheckBuffer((BufferObject *)(self)))
1668 return NULL;
1669
1670 if (!PyArg_ParseTuple(args, Py_ssize_t_fmt Py_ssize_t_fmt, &start, &end))
1671 return NULL;
1672
1673 return RangeNew(((BufferObject *)(self))->buf, start, end);
1674 }
1675
1676 /* Line range object - Definitions
1677 */
1678
1679 static struct PyMethodDef RangeMethods[] = {
1680 /* name, function, calling, documentation */
1681 {"append", RangeAppend, 1, "Append data to the Vim range" },
1682 { NULL, NULL, 0, NULL }
1683 };
1684
1685 static PySequenceMethods RangeAsSeq = {
1686 (PyInquiry) RangeLength, /* sq_length, len(x) */
1687 (binaryfunc) 0, /* RangeConcat, */ /* sq_concat, x+y */
1688 (PyIntArgFunc) 0, /* RangeRepeat, */ /* sq_repeat, x*n */
1689 (PyIntArgFunc) RangeItem, /* sq_item, x[i] */
1690 (PyIntIntArgFunc) RangeSlice, /* sq_slice, x[i:j] */
1691 (PyIntObjArgProc) RangeAssItem, /* sq_ass_item, x[i]=v */
1692 (PyIntIntObjArgProc) RangeAssSlice, /* sq_ass_slice, x[i:j]=v */
1693 };
1694
1695 static PyTypeObject RangeType = {
1696 PyObject_HEAD_INIT(0)
1697 0,
1698 "range",
1699 sizeof(RangeObject),
1700 0,
1701
1702 (destructor) RangeDestructor, /* tp_dealloc, refcount==0 */
1703 (printfunc) 0, /* tp_print, print x */
1704 (getattrfunc) RangeGetattr, /* tp_getattr, x.attr */
1705 (setattrfunc) 0, /* tp_setattr, x.attr=v */
1706 (cmpfunc) 0, /* tp_compare, x>y */
1707 (reprfunc) RangeRepr, /* tp_repr, `x`, print x */
1708
1709 0, /* as number */
1710 &RangeAsSeq, /* as sequence */
1711 0, /* as mapping */
1712
1713 (hashfunc) 0, /* tp_hash, dict(x) */
1714 (ternaryfunc) 0, /* tp_call, x() */
1715 (reprfunc) 0, /* tp_str, str(x) */
1716 };
1717
1718 /* Line range object - Implementation
1719 */
1720
1721 static PyObject *
1722 RangeNew(buf_T *buf, PyInt start, PyInt end)
1723 {
1724 BufferObject *bufr;
1725 RangeObject *self;
1726 self = PyObject_NEW(RangeObject, &RangeType);
1727 if (self == NULL)
1728 return NULL;
1729
1730 bufr = (BufferObject *)BufferNew(buf);
1731 if (bufr == NULL)
1732 {
1733 Py_DECREF(self);
1734 return NULL;
1735 }
1736 Py_INCREF(bufr);
1737
1738 self->buf = bufr;
1739 self->start = start;
1740 self->end = end;
1741
1742 return (PyObject *)(self);
1743 }
1744
1745 static void
1746 RangeDestructor(PyObject *self)
1747 {
1748 Py_DECREF(((RangeObject *)(self))->buf);
1749 Py_DECREF(self);
1750 }
1751
1752 static PyObject *
1753 RangeGetattr(PyObject *self, char *name)
1754 {
1755 if (strcmp(name, "start") == 0)
1756 return Py_BuildValue(Py_ssize_t_fmt, ((RangeObject *)(self))->start - 1);
1757 else if (strcmp(name, "end") == 0)
1758 return Py_BuildValue(Py_ssize_t_fmt, ((RangeObject *)(self))->end - 1);
1759 else
1760 return Py_FindMethod(RangeMethods, self, name);
1761 }
1762
1763 static PyObject *
1764 RangeRepr(PyObject *self)
1765 {
1766 static char repr[100];
1767 RangeObject *this = (RangeObject *)(self);
1768
1769 if (this->buf->buf == INVALID_BUFFER_VALUE)
1770 {
1771 vim_snprintf(repr, 100, "<range object (for deleted buffer) at %p>",
1772 (self));
1773 return PyString_FromString(repr);
1774 }
1775 else
1776 {
1777 char *name = (char *)this->buf->buf->b_fname;
1778 int len;
1779
1780 if (name == NULL)
1781 name = "";
1782 len = (int)strlen(name);
1783
1784 if (len > 45)
1785 name = name + (45 - len);
1786
1787 vim_snprintf(repr, 100, "<range %s%s (%d:%d)>",
1788 len > 45 ? "..." : "", name,
1789 this->start, this->end);
1790
1791 return PyString_FromString(repr);
1792 }
1793 }
1794
1795 /****************/
1796
1797 static PyInt
1798 RangeLength(PyObject *self)
1799 {
1800 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
1801 if (CheckBuffer(((RangeObject *)(self))->buf))
1802 return -1; /* ??? */
1803
1804 return (((RangeObject *)(self))->end - ((RangeObject *)(self))->start + 1);
1805 }
1806
1807 static PyObject *
1808 RangeItem(PyObject *self, PyInt n)
1809 {
1810 return RBItem(((RangeObject *)(self))->buf, n,
1811 ((RangeObject *)(self))->start,
1812 ((RangeObject *)(self))->end);
1813 }
1814
1815 static PyObject *
1816 RangeSlice(PyObject *self, PyInt lo, PyInt hi)
1817 {
1818 return RBSlice(((RangeObject *)(self))->buf, lo, hi,
1819 ((RangeObject *)(self))->start,
1820 ((RangeObject *)(self))->end);
1821 }
1822
1823 static PyInt
1824 RangeAssItem(PyObject *self, PyInt n, PyObject *val)
1825 {
1826 return RBAssItem(((RangeObject *)(self))->buf, n, val,
1827 ((RangeObject *)(self))->start,
1828 ((RangeObject *)(self))->end,
1829 &((RangeObject *)(self))->end);
1830 }
1831
1832 static PyInt
1833 RangeAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
1834 {
1835 return RBAssSlice(((RangeObject *)(self))->buf, lo, hi, val,
1836 ((RangeObject *)(self))->start,
1837 ((RangeObject *)(self))->end,
1838 &((RangeObject *)(self))->end);
1839 }
1840
1841 static PyObject *
1842 RangeAppend(PyObject *self, PyObject *args)
1843 {
1844 return RBAppend(((RangeObject *)(self))->buf, args,
1845 ((RangeObject *)(self))->start,
1846 ((RangeObject *)(self))->end,
1847 &((RangeObject *)(self))->end);
1848 }
1849
1850 /* Buffer list object - Definitions
1851 */
1852
1853 typedef struct
1854 {
1855 PyObject_HEAD
1856 }
1857 BufListObject;
1858
1859 static PySequenceMethods BufListAsSeq = {
1860 (PyInquiry) BufListLength, /* sq_length, len(x) */
1861 (binaryfunc) 0, /* sq_concat, x+y */
1862 (PyIntArgFunc) 0, /* sq_repeat, x*n */
1863 (PyIntArgFunc) BufListItem, /* sq_item, x[i] */
1864 (PyIntIntArgFunc) 0, /* sq_slice, x[i:j] */
1865 (PyIntObjArgProc) 0, /* sq_ass_item, x[i]=v */
1866 (PyIntIntObjArgProc) 0, /* sq_ass_slice, x[i:j]=v */
1867 };
1868
1869 static PyTypeObject BufListType = {
1870 PyObject_HEAD_INIT(0)
1871 0,
1872 "buffer list",
1873 sizeof(BufListObject),
1874 0,
1875
1876 (destructor) 0, /* tp_dealloc, refcount==0 */
1877 (printfunc) 0, /* tp_print, print x */
1878 (getattrfunc) 0, /* tp_getattr, x.attr */
1879 (setattrfunc) 0, /* tp_setattr, x.attr=v */
1880 (cmpfunc) 0, /* tp_compare, x>y */
1881 (reprfunc) 0, /* tp_repr, `x`, print x */
1882
1883 0, /* as number */
1884 &BufListAsSeq, /* as sequence */
1885 0, /* as mapping */
1886
1887 (hashfunc) 0, /* tp_hash, dict(x) */
1888 (ternaryfunc) 0, /* tp_call, x() */
1889 (reprfunc) 0, /* tp_str, str(x) */
1890 };
1891
1892 /* Buffer list object - Implementation
1893 */
1894
1895 static PyInt
1896 BufListLength(PyObject *self UNUSED)
1897 {
1898 buf_T *b = firstbuf;
1899 PyInt n = 0;
1900
1901 while (b)
1902 {
1903 ++n;
1904 b = b->b_next;
1905 }
1906
1907 return n;
1908 }
1909
1910 static PyObject *
1911 BufListItem(PyObject *self UNUSED, PyInt n)
1912 {
1913 buf_T *b;
1914
1915 for (b = firstbuf; b; b = b->b_next, --n)
1916 {
1917 if (n == 0)
1918 return BufferNew(b);
1919 }
1920
1921 PyErr_SetString(PyExc_IndexError, _("no such buffer"));
1922 return NULL;
1923 }
1924
1925 /* Window object - Definitions
1926 */
1927
1928 static struct PyMethodDef WindowMethods[] = {
1929 /* name, function, calling, documentation */
1930 { NULL, NULL, 0, NULL }
1931 };
1932
1933 static PyTypeObject WindowType = {
1934 PyObject_HEAD_INIT(0)
1935 0,
1936 "window",
1937 sizeof(WindowObject),
1938 0,
1939
1940 (destructor) WindowDestructor, /* tp_dealloc, refcount==0 */
1941 (printfunc) 0, /* tp_print, print x */
1942 (getattrfunc) WindowGetattr, /* tp_getattr, x.attr */
1943 (setattrfunc) WindowSetattr, /* tp_setattr, x.attr=v */
1944 (cmpfunc) 0, /* tp_compare, x>y */
1945 (reprfunc) WindowRepr, /* tp_repr, `x`, print x */
1946
1947 0, /* as number */
1948 0, /* as sequence */
1949 0, /* as mapping */
1950
1951 (hashfunc) 0, /* tp_hash, dict(x) */
1952 (ternaryfunc) 0, /* tp_call, x() */
1953 (reprfunc) 0, /* tp_str, str(x) */
1954 };
1955
1956 /* Window object - Implementation
1957 */
1958
1959 static PyObject *
1960 WindowNew(win_T *win)
1961 {
1962 /* We need to handle deletion of windows underneath us.
1963 * If we add a "w_python_ref" field to the win_T structure,
1964 * then we can get at it in win_free() in vim. We then
1965 * need to create only ONE Python object per window - if
1966 * we try to create a second, just INCREF the existing one
1967 * and return it. The (single) Python object referring to
1968 * the window is stored in "w_python_ref".
1969 * On a win_free() we set the Python object's win_T* field
1970 * to an invalid value. We trap all uses of a window
1971 * object, and reject them if the win_T* field is invalid.
1972 */
1973
1974 WindowObject *self;
1975
1976 if (win->w_python_ref)
1977 {
1978 self = win->w_python_ref;
1979 Py_INCREF(self);
1980 }
1981 else
1982 {
1983 self = PyObject_NEW(WindowObject, &WindowType);
1984 if (self == NULL)
1985 return NULL;
1986 self->win = win;
1987 win->w_python_ref = self;
1988 }
1989
1990 return (PyObject *)(self);
1991 }
1992
1993 static void
1994 WindowDestructor(PyObject *self)
1995 {
1996 WindowObject *this = (WindowObject *)(self);
1997
1998 if (this->win && this->win != INVALID_WINDOW_VALUE)
1999 this->win->w_python_ref = NULL;
2000
2001 Py_DECREF(self);
2002 }
2003
2004 static int
2005 CheckWindow(WindowObject *this)
2006 {
2007 if (this->win == INVALID_WINDOW_VALUE)
2008 {
2009 PyErr_SetVim(_("attempt to refer to deleted window"));
2010 return -1;
2011 }
2012
2013 return 0;
2014 }
2015
2016 static PyObject *
2017 WindowGetattr(PyObject *self, char *name)
2018 {
2019 WindowObject *this = (WindowObject *)(self);
2020
2021 if (CheckWindow(this))
2022 return NULL;
2023
2024 if (strcmp(name, "buffer") == 0)
2025 return (PyObject *)BufferNew(this->win->w_buffer);
2026 else if (strcmp(name, "cursor") == 0)
2027 {
2028 pos_T *pos = &this->win->w_cursor;
2029
2030 return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));
2031 }
2032 else if (strcmp(name, "height") == 0)
2033 return Py_BuildValue("l", (long)(this->win->w_height));
2034 #ifdef FEAT_VERTSPLIT
2035 else if (strcmp(name, "width") == 0)
2036 return Py_BuildValue("l", (long)(W_WIDTH(this->win)));
2037 #endif
2038 else if (strcmp(name,"__members__") == 0)
2039 return Py_BuildValue("[sss]", "buffer", "cursor", "height");
2040 else
2041 return Py_FindMethod(WindowMethods, self, name);
2042 }
2043
2044 static int
2045 WindowSetattr(PyObject *self, char *name, PyObject *val)
2046 {
2047 WindowObject *this = (WindowObject *)(self);
2048
2049 if (CheckWindow(this))
2050 return -1;
2051
2052 if (strcmp(name, "buffer") == 0)
2053 {
2054 PyErr_SetString(PyExc_TypeError, _("readonly attribute"));
2055 return -1;
2056 }
2057 else if (strcmp(name, "cursor") == 0)
2058 {
2059 long lnum;
2060 long col;
2061 long len;
2062
2063 if (!PyArg_Parse(val, "(ll)", &lnum, &col))
2064 return -1;
2065
2066 if (lnum <= 0 || lnum > this->win->w_buffer->b_ml.ml_line_count)
2067 {
2068 PyErr_SetVim(_("cursor position outside buffer"));
2069 return -1;
2070 }
2071
2072 /* Check for keyboard interrupts */
2073 if (VimErrorCheck())
2074 return -1;
2075
2076 /* When column is out of range silently correct it. */
2077 len = STRLEN(ml_get_buf(this->win->w_buffer, lnum, FALSE));
2078 if (col > len)
2079 col = len;
2080
2081 this->win->w_cursor.lnum = lnum;
2082 this->win->w_cursor.col = col;
2083 #ifdef FEAT_VIRTUALEDIT
2084 this->win->w_cursor.coladd = 0;
2085 #endif
2086 update_screen(VALID);
2087
2088 return 0;
2089 }
2090 else if (strcmp(name, "height") == 0)
2091 {
2092 int height;
2093 win_T *savewin;
2094
2095 if (!PyArg_Parse(val, "i", &height))
2096 return -1;
2097
2098 #ifdef FEAT_GUI
2099 need_mouse_correct = TRUE;
2100 #endif
2101 savewin = curwin;
2102 curwin = this->win;
2103 win_setheight(height);
2104 curwin = savewin;
2105
2106 /* Check for keyboard interrupts */
2107 if (VimErrorCheck())
2108 return -1;
2109
2110 return 0;
2111 }
2112 #ifdef FEAT_VERTSPLIT
2113 else if (strcmp(name, "width") == 0)
2114 {
2115 int width;
2116 win_T *savewin;
2117
2118 if (!PyArg_Parse(val, "i", &width))
2119 return -1;
2120
2121 #ifdef FEAT_GUI
2122 need_mouse_correct = TRUE;
2123 #endif
2124 savewin = curwin;
2125 curwin = this->win;
2126 win_setwidth(width);
2127 curwin = savewin;
2128
2129 /* Check for keyboard interrupts */
2130 if (VimErrorCheck())
2131 return -1;
2132
2133 return 0;
2134 }
2135 #endif
2136 else
2137 {
2138 PyErr_SetString(PyExc_AttributeError, name);
2139 return -1;
2140 }
2141 }
2142
2143 static PyObject *
2144 WindowRepr(PyObject *self)
2145 {
2146 static char repr[100];
2147 WindowObject *this = (WindowObject *)(self);
2148
2149 if (this->win == INVALID_WINDOW_VALUE)
2150 {
2151 vim_snprintf(repr, 100, _("<window object (deleted) at %p>"), (self));
2152 return PyString_FromString(repr);
2153 }
2154 else
2155 {
2156 int i = 0;
2157 win_T *w;
2158
2159 for (w = firstwin; w != NULL && w != this->win; w = W_NEXT(w))
2160 ++i;
2161
2162 if (w == NULL)
2163 vim_snprintf(repr, 100, _("<window object (unknown) at %p>"),
2164 (self));
2165 else
2166 vim_snprintf(repr, 100, _("<window %d>"), i);
2167
2168 return PyString_FromString(repr);
2169 }
2170 }
2171
2172 /* Window list object - Definitions
2173 */
2174
2175 typedef struct
2176 {
2177 PyObject_HEAD
2178 }
2179 WinListObject;
2180
2181 static PySequenceMethods WinListAsSeq = {
2182 (PyInquiry) WinListLength, /* sq_length, len(x) */
2183 (binaryfunc) 0, /* sq_concat, x+y */
2184 (PyIntArgFunc) 0, /* sq_repeat, x*n */
2185 (PyIntArgFunc) WinListItem, /* sq_item, x[i] */
2186 (PyIntIntArgFunc) 0, /* sq_slice, x[i:j] */
2187 (PyIntObjArgProc) 0, /* sq_ass_item, x[i]=v */
2188 (PyIntIntObjArgProc) 0, /* sq_ass_slice, x[i:j]=v */
2189 };
2190
2191 static PyTypeObject WinListType = {
2192 PyObject_HEAD_INIT(0)
2193 0,
2194 "window list",
2195 sizeof(WinListObject),
2196 0,
2197
2198 (destructor) 0, /* tp_dealloc, refcount==0 */
2199 (printfunc) 0, /* tp_print, print x */
2200 (getattrfunc) 0, /* tp_getattr, x.attr */
2201 (setattrfunc) 0, /* tp_setattr, x.attr=v */
2202 (cmpfunc) 0, /* tp_compare, x>y */
2203 (reprfunc) 0, /* tp_repr, `x`, print x */
2204
2205 0, /* as number */
2206 &WinListAsSeq, /* as sequence */
2207 0, /* as mapping */
2208
2209 (hashfunc) 0, /* tp_hash, dict(x) */
2210 (ternaryfunc) 0, /* tp_call, x() */
2211 (reprfunc) 0, /* tp_str, str(x) */
2212 };
2213
2214 /* Window list object - Implementation
2215 */
2216 static PyInt
2217 WinListLength(PyObject *self UNUSED)
2218 {
2219 win_T *w = firstwin;
2220 PyInt n = 0;
2221
2222 while (w != NULL)
2223 {
2224 ++n;
2225 w = W_NEXT(w);
2226 }
2227
2228 return n;
2229 }
2230
2231 static PyObject *
2232 WinListItem(PyObject *self UNUSED, PyInt n)
2233 {
2234 win_T *w;
2235
2236 for (w = firstwin; w != NULL; w = W_NEXT(w), --n)
2237 if (n == 0)
2238 return WindowNew(w);
2239
2240 PyErr_SetString(PyExc_IndexError, _("no such window"));
2241 return NULL;
2242 }
2243
2244 /* Current items object - Definitions
2245 */
2246
2247 typedef struct
2248 {
2249 PyObject_HEAD
2250 }
2251 CurrentObject;
2252
2253 static PyTypeObject CurrentType = {
2254 PyObject_HEAD_INIT(0)
2255 0,
2256 "current data",
2257 sizeof(CurrentObject),
2258 0,
2259
2260 (destructor) 0, /* tp_dealloc, refcount==0 */
2261 (printfunc) 0, /* tp_print, print x */
2262 (getattrfunc) CurrentGetattr, /* tp_getattr, x.attr */
2263 (setattrfunc) CurrentSetattr, /* tp_setattr, x.attr=v */
2264 (cmpfunc) 0, /* tp_compare, x>y */
2265 (reprfunc) 0, /* tp_repr, `x`, print x */
2266
2267 0, /* as number */
2268 0, /* as sequence */
2269 0, /* as mapping */
2270
2271 (hashfunc) 0, /* tp_hash, dict(x) */
2272 (ternaryfunc) 0, /* tp_call, x() */
2273 (reprfunc) 0, /* tp_str, str(x) */
2274 };
2275
2276 /* Current items object - Implementation
2277 */
2278 static PyObject *
2279 CurrentGetattr(PyObject *self UNUSED, char *name)
2280 {
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");
2291 else
2292 {
2293 PyErr_SetString(PyExc_AttributeError, name);
2294 return NULL;
2295 }
2296 }
2297
2298 static int
2299 CurrentSetattr(PyObject *self UNUSED, char *name, PyObject *value)
2300 {
2301 if (strcmp(name, "line") == 0)
2302 {
2303 if (SetBufferLine(curbuf, (PyInt)curwin->w_cursor.lnum, value, NULL) == FAIL)
2304 return -1;
2305
2306 return 0;
2307 }
2308 else
2309 {
2310 PyErr_SetString(PyExc_AttributeError, name);
2311 return -1;
2312 }
2313 }
2314
2315 /* External interface
2316 */
2317
2318 void
2319 python_buffer_free(buf_T *buf)
2320 {
2321 if (buf->b_python_ref != NULL)
2322 {
2323 BufferObject *bp = buf->b_python_ref;
2324 bp->buf = INVALID_BUFFER_VALUE;
2325 buf->b_python_ref = NULL;
2326 }
2327 }
2328
2329 #if defined(FEAT_WINDOWS) || defined(PROTO)
2330 void
2331 python_window_free(win_T *win)
2332 {
2333 if (win->w_python_ref != NULL)
2334 {
2335 WindowObject *wp = win->w_python_ref;
2336 wp->win = INVALID_WINDOW_VALUE;
2337 win->w_python_ref = NULL;
2338 }
2339 }
2340 #endif
2341
2342 static BufListObject TheBufferList =
2343 {
2344 PyObject_HEAD_INIT(&BufListType)
2345 };
2346
2347 static WinListObject TheWindowList =
2348 {
2349 PyObject_HEAD_INIT(&WinListType)
2350 };
2351
2352 static CurrentObject TheCurrent =
2353 {
2354 PyObject_HEAD_INIT(&CurrentType)
2355 };
2356
2357 static int
2358 PythonMod_Init(void)
2359 {
2360 PyObject *mod;
2361 PyObject *dict;
2362 /* The special value is removed from sys.path in Python_Init(). */
2363 static char *(argv[2]) = {"/must>not&exist/foo", NULL};
2364
2365 /* Fixups... */
2366 BufferType.ob_type = &PyType_Type;
2367 RangeType.ob_type = &PyType_Type;
2368 WindowType.ob_type = &PyType_Type;
2369 BufListType.ob_type = &PyType_Type;
2370 WinListType.ob_type = &PyType_Type;
2371 CurrentType.ob_type = &PyType_Type;
2372
2373 /* Set sys.argv[] to avoid a crash in warn(). */
2374 PySys_SetArgv(1, argv);
2375
2376 mod = Py_InitModule4("vim", VimMethods, (char *)NULL, (PyObject *)NULL, PYTHON_API_VERSION);
2377 dict = PyModule_GetDict(mod);
2378
2379 VimError = Py_BuildValue("s", "vim.error");
2380
2381 PyDict_SetItemString(dict, "error", VimError);
2382 PyDict_SetItemString(dict, "buffers", (PyObject *)(void *)&TheBufferList);
2383 PyDict_SetItemString(dict, "current", (PyObject *)(void *)&TheCurrent);
2384 PyDict_SetItemString(dict, "windows", (PyObject *)(void *)&TheWindowList);
2385
2386 if (PyErr_Occurred())
2387 return -1;
2388
2389 return 0;
2390 }
2391
2392 /*************************************************************************
2393 * 4. Utility functions for handling the interface between Vim and Python.
2394 */
2395
2396 /* Get a line from the specified buffer. The line number is
2397 * in Vim format (1-based). The line is returned as a Python
2398 * string object.
2399 */
2400 static PyObject *
2401 GetBufferLine(buf_T *buf, PyInt n)
2402 {
2403 return LineToString((char *)ml_get_buf(buf, (linenr_T)n, FALSE));
2404 }
2405
2406 /* Get a list of lines from the specified buffer. The line numbers
2407 * are in Vim format (1-based). The range is from lo up to, but not
2408 * including, hi. The list is returned as a Python list of string objects.
2409 */
2410 static PyObject *
2411 GetBufferLineList(buf_T *buf, PyInt lo, PyInt hi)
2412 {
2413 PyInt i;
2414 PyInt n = hi - lo;
2415 PyObject *list = PyList_New(n);
2416
2417 if (list == NULL)
2418 return NULL;
2419
2420 for (i = 0; i < n; ++i)
2421 {
2422 PyObject *str = LineToString((char *)ml_get_buf(buf, (linenr_T)(lo+i), FALSE));
2423
2424 /* Error check - was the Python string creation OK? */
2425 if (str == NULL)
2426 {
2427 Py_DECREF(list);
2428 return NULL;
2429 }
2430
2431 /* Set the list item */
2432 if (PyList_SetItem(list, i, str))
2433 {
2434 Py_DECREF(str);
2435 Py_DECREF(list);
2436 return NULL;
2437 }
2438 }
2439
2440 /* The ownership of the Python list is passed to the caller (ie,
2441 * the caller should Py_DECREF() the object when it is finished
2442 * with it).
2443 */
2444
2445 return list;
2446 }
2447
2448 /*
2449 * Check if deleting lines made the cursor position invalid.
2450 * Changed the lines from "lo" to "hi" and added "extra" lines (negative if
2451 * deleted).
2452 */
2453 static void
2454 py_fix_cursor(linenr_T lo, linenr_T hi, linenr_T extra)
2455 {
2456 if (curwin->w_cursor.lnum >= lo)
2457 {
2458 /* Adjust the cursor position if it's in/after the changed
2459 * lines. */
2460 if (curwin->w_cursor.lnum >= hi)
2461 {
2462 curwin->w_cursor.lnum += extra;
2463 check_cursor_col();
2464 }
2465 else if (extra < 0)
2466 {
2467 curwin->w_cursor.lnum = lo;
2468 check_cursor();
2469 }
2470 else
2471 check_cursor_col();
2472 changed_cline_bef_curs();
2473 }
2474 invalidate_botline();
2475 }
2476
2477 /* Replace a line in the specified buffer. The line number is
2478 * in Vim format (1-based). The replacement line is given as
2479 * a Python string object. The object is checked for validity
2480 * and correct format. Errors are returned as a value of FAIL.
2481 * The return value is OK on success.
2482 * If OK is returned and len_change is not NULL, *len_change
2483 * is set to the change in the buffer length.
2484 */
2485 static int
2486 SetBufferLine(buf_T *buf, PyInt n, PyObject *line, PyInt *len_change)
2487 {
2488 /* First of all, we check the thpe of the supplied Python object.
2489 * There are three cases:
2490 * 1. NULL, or None - this is a deletion.
2491 * 2. A string - this is a replacement.
2492 * 3. Anything else - this is an error.
2493 */
2494 if (line == Py_None || line == NULL)
2495 {
2496 buf_T *savebuf = curbuf;
2497
2498 PyErr_Clear();
2499 curbuf = buf;
2500
2501 if (u_savedel((linenr_T)n, 1L) == FAIL)
2502 PyErr_SetVim(_("cannot save undo information"));
2503 else if (ml_delete((linenr_T)n, FALSE) == FAIL)
2504 PyErr_SetVim(_("cannot delete line"));
2505 else
2506 {
2507 if (buf == curwin->w_buffer)
2508 py_fix_cursor((linenr_T)n, (linenr_T)n + 1, (linenr_T)-1);
2509 deleted_lines_mark((linenr_T)n, 1L);
2510 }
2511
2512 curbuf = savebuf;
2513
2514 if (PyErr_Occurred() || VimErrorCheck())
2515 return FAIL;
2516
2517 if (len_change)
2518 *len_change = -1;
2519
2520 return OK;
2521 }
2522 else if (PyString_Check(line))
2523 {
2524 char *save = StringToLine(line);
2525 buf_T *savebuf = curbuf;
2526
2527 if (save == NULL)
2528 return FAIL;
2529
2530 /* We do not need to free "save" if ml_replace() consumes it. */
2531 PyErr_Clear();
2532 curbuf = buf;
2533
2534 if (u_savesub((linenr_T)n) == FAIL)
2535 {
2536 PyErr_SetVim(_("cannot save undo information"));
2537 vim_free(save);
2538 }
2539 else if (ml_replace((linenr_T)n, (char_u *)save, FALSE) == FAIL)
2540 {
2541 PyErr_SetVim(_("cannot replace line"));
2542 vim_free(save);
2543 }
2544 else
2545 changed_bytes((linenr_T)n, 0);
2546
2547 curbuf = savebuf;
2548
2549 /* Check that the cursor is not beyond the end of the line now. */
2550 if (buf == curwin->w_buffer)
2551 check_cursor_col();
2552
2553 if (PyErr_Occurred() || VimErrorCheck())
2554 return FAIL;
2555
2556 if (len_change)
2557 *len_change = 0;
2558
2559 return OK;
2560 }
2561 else
2562 {
2563 PyErr_BadArgument();
2564 return FAIL;
2565 }
2566 }
2567
2568 /* Replace a range of lines in the specified buffer. The line numbers are in
2569 * Vim format (1-based). The range is from lo up to, but not including, hi.
2570 * The replacement lines are given as a Python list of string objects. The
2571 * list is checked for validity and correct format. Errors are returned as a
2572 * value of FAIL. The return value is OK on success.
2573 * If OK is returned and len_change is not NULL, *len_change
2574 * is set to the change in the buffer length.
2575 */
2576 static int
2577 SetBufferLineList(buf_T *buf, PyInt lo, PyInt hi, PyObject *list, PyInt *len_change)
2578 {
2579 /* First of all, we check the thpe of the supplied Python object.
2580 * There are three cases:
2581 * 1. NULL, or None - this is a deletion.
2582 * 2. A list - this is a replacement.
2583 * 3. Anything else - this is an error.
2584 */
2585 if (list == Py_None || list == NULL)
2586 {
2587 PyInt i;
2588 PyInt n = (int)(hi - lo);
2589 buf_T *savebuf = curbuf;
2590
2591 PyErr_Clear();
2592 curbuf = buf;
2593
2594 if (u_savedel((linenr_T)lo, (long)n) == FAIL)
2595 PyErr_SetVim(_("cannot save undo information"));
2596 else
2597 {
2598 for (i = 0; i < n; ++i)
2599 {
2600 if (ml_delete((linenr_T)lo, FALSE) == FAIL)
2601 {
2602 PyErr_SetVim(_("cannot delete line"));
2603 break;
2604 }
2605 }
2606 if (buf == curwin->w_buffer)
2607 py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)-n);
2608 deleted_lines_mark((linenr_T)lo, (long)i);
2609 }
2610
2611 curbuf = savebuf;
2612
2613 if (PyErr_Occurred() || VimErrorCheck())
2614 return FAIL;
2615
2616 if (len_change)
2617 *len_change = -n;
2618
2619 return OK;
2620 }
2621 else if (PyList_Check(list))
2622 {
2623 PyInt i;
2624 PyInt new_len = PyList_Size(list);
2625 PyInt old_len = hi - lo;
2626 PyInt extra = 0; /* lines added to text, can be negative */
2627 char **array;
2628 buf_T *savebuf;
2629
2630 if (new_len == 0) /* avoid allocating zero bytes */
2631 array = NULL;
2632 else
2633 {
2634 array = (char **)alloc((unsigned)(new_len * sizeof(char *)));
2635 if (array == NULL)
2636 {
2637 PyErr_NoMemory();
2638 return FAIL;
2639 }
2640 }
2641
2642 for (i = 0; i < new_len; ++i)
2643 {
2644 PyObject *line = PyList_GetItem(list, i);
2645
2646 array[i] = StringToLine(line);
2647 if (array[i] == NULL)
2648 {
2649 while (i)
2650 vim_free(array[--i]);
2651 vim_free(array);
2652 return FAIL;
2653 }
2654 }
2655
2656 savebuf = curbuf;
2657
2658 PyErr_Clear();
2659 curbuf = buf;
2660
2661 if (u_save((linenr_T)(lo-1), (linenr_T)hi) == FAIL)
2662 PyErr_SetVim(_("cannot save undo information"));
2663
2664 /* If the size of the range is reducing (ie, new_len < old_len) we
2665 * need to delete some old_len. We do this at the start, by
2666 * repeatedly deleting line "lo".
2667 */
2668 if (!PyErr_Occurred())
2669 {
2670 for (i = 0; i < old_len - new_len; ++i)
2671 if (ml_delete((linenr_T)lo, FALSE) == FAIL)
2672 {
2673 PyErr_SetVim(_("cannot delete line"));
2674 break;
2675 }
2676 extra -= i;
2677 }
2678
2679 /* For as long as possible, replace the existing old_len with the
2680 * new old_len. This is a more efficient operation, as it requires
2681 * less memory allocation and freeing.
2682 */
2683 if (!PyErr_Occurred())
2684 {
2685 for (i = 0; i < old_len && i < new_len; ++i)
2686 if (ml_replace((linenr_T)(lo+i), (char_u *)array[i], FALSE)
2687 == FAIL)
2688 {
2689 PyErr_SetVim(_("cannot replace line"));
2690 break;
2691 }
2692 }
2693 else
2694 i = 0;
2695
2696 /* Now we may need to insert the remaining new old_len. If we do, we
2697 * must free the strings as we finish with them (we can't pass the
2698 * responsibility to vim in this case).
2699 */
2700 if (!PyErr_Occurred())
2701 {
2702 while (i < new_len)
2703 {
2704 if (ml_append((linenr_T)(lo + i - 1),
2705 (char_u *)array[i], 0, FALSE) == FAIL)
2706 {
2707 PyErr_SetVim(_("cannot insert line"));
2708 break;
2709 }
2710 vim_free(array[i]);
2711 ++i;
2712 ++extra;
2713 }
2714 }
2715
2716 /* Free any left-over old_len, as a result of an error */
2717 while (i < new_len)
2718 {
2719 vim_free(array[i]);
2720 ++i;
2721 }
2722
2723 /* Free the array of old_len. All of its contents have now
2724 * been dealt with (either freed, or the responsibility passed
2725 * to vim.
2726 */
2727 vim_free(array);
2728
2729 /* Adjust marks. Invalidate any which lie in the
2730 * changed range, and move any in the remainder of the buffer.
2731 */
2732 mark_adjust((linenr_T)lo, (linenr_T)(hi - 1),
2733 (long)MAXLNUM, (long)extra);
2734 changed_lines((linenr_T)lo, 0, (linenr_T)hi, (long)extra);
2735
2736 if (buf == curwin->w_buffer)
2737 py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)extra);
2738
2739 curbuf = savebuf;
2740
2741 if (PyErr_Occurred() || VimErrorCheck())
2742 return FAIL;
2743
2744 if (len_change)
2745 *len_change = new_len - old_len;
2746
2747 return OK;
2748 }
2749 else
2750 {
2751 PyErr_BadArgument();
2752 return FAIL;
2753 }
2754 }
2755
2756 /* Insert a number of lines into the specified buffer after the specifed line.
2757 * The line number is in Vim format (1-based). The lines to be inserted are
2758 * given as a Python list of string objects or as a single string. The lines
2759 * to be added are checked for validity and correct format. Errors are
2760 * returned as a value of FAIL. The return value is OK on success.
2761 * If OK is returned and len_change is not NULL, *len_change
2762 * is set to the change in the buffer length.
2763 */
2764 static int
2765 InsertBufferLines(buf_T *buf, PyInt n, PyObject *lines, PyInt *len_change)
2766 {
2767 /* First of all, we check the type of the supplied Python object.
2768 * It must be a string or a list, or the call is in error.
2769 */
2770 if (PyString_Check(lines))
2771 {
2772 char *str = StringToLine(lines);
2773 buf_T *savebuf;
2774
2775 if (str == NULL)
2776 return FAIL;
2777
2778 savebuf = curbuf;
2779
2780 PyErr_Clear();
2781 curbuf = buf;
2782
2783 if (u_save((linenr_T)n, (linenr_T)(n+1)) == FAIL)
2784 PyErr_SetVim(_("cannot save undo information"));
2785 else if (ml_append((linenr_T)n, (char_u *)str, 0, FALSE) == FAIL)
2786 PyErr_SetVim(_("cannot insert line"));
2787 else
2788 appended_lines_mark((linenr_T)n, 1L);
2789
2790 vim_free(str);
2791 curbuf = savebuf;
2792 update_screen(VALID);
2793
2794 if (PyErr_Occurred() || VimErrorCheck())
2795 return FAIL;
2796
2797 if (len_change)
2798 *len_change = 1;
2799
2800 return OK;
2801 }
2802 else if (PyList_Check(lines))
2803 {
2804 PyInt i;
2805 PyInt size = PyList_Size(lines);
2806 char **array;
2807 buf_T *savebuf;
2808
2809 array = (char **)alloc((unsigned)(size * sizeof(char *)));
2810 if (array == NULL)
2811 {
2812 PyErr_NoMemory();
2813 return FAIL;
2814 }
2815
2816 for (i = 0; i < size; ++i)
2817 {
2818 PyObject *line = PyList_GetItem(lines, i);
2819 array[i] = StringToLine(line);
2820
2821 if (array[i] == NULL)
2822 {
2823 while (i)
2824 vim_free(array[--i]);
2825 vim_free(array);
2826 return FAIL;
2827 }
2828 }
2829
2830 savebuf = curbuf;
2831
2832 PyErr_Clear();
2833 curbuf = buf;
2834
2835 if (u_save((linenr_T)n, (linenr_T)(n + 1)) == FAIL)
2836 PyErr_SetVim(_("cannot save undo information"));
2837 else
2838 {
2839 for (i = 0; i < size; ++i)
2840 {
2841 if (ml_append((linenr_T)(n + i),
2842 (char_u *)array[i], 0, FALSE) == FAIL)
2843 {
2844 PyErr_SetVim(_("cannot insert line"));
2845
2846 /* Free the rest of the lines */
2847 while (i < size)
2848 vim_free(array[i++]);
2849
2850 break;
2851 }
2852 vim_free(array[i]);
2853 }
2854 if (i > 0)
2855 appended_lines_mark((linenr_T)n, (long)i);
2856 }
2857
2858 /* Free the array of lines. All of its contents have now
2859 * been freed.
2860 */
2861 vim_free(array);
2862
2863 curbuf = savebuf;
2864 update_screen(VALID);
2865
2866 if (PyErr_Occurred() || VimErrorCheck())
2867 return FAIL;
2868
2869 if (len_change)
2870 *len_change = size;
2871
2872 return OK;
2873 }
2874 else
2875 {
2876 PyErr_BadArgument();
2877 return FAIL;
2878 }
2879 }
2880
2881 /* Convert a Vim line into a Python string.
2882 * All internal newlines are replaced by null characters.
2883 *
2884 * On errors, the Python exception data is set, and NULL is returned.
2885 */
2886 static PyObject *
2887 LineToString(const char *str)
2888 {
2889 PyObject *result;
2890 PyInt len = strlen(str);
2891 char *p;
2892
2893 /* Allocate an Python string object, with uninitialised contents. We
2894 * must do it this way, so that we can modify the string in place
2895 * later. See the Python source, Objects/stringobject.c for details.
2896 */
2897 result = PyString_FromStringAndSize(NULL, len);
2898 if (result == NULL)
2899 return NULL;
2900
2901 p = PyString_AsString(result);
2902
2903 while (*str)
2904 {
2905 if (*str == '\n')
2906 *p = '\0';
2907 else
2908 *p = *str;
2909
2910 ++p;
2911 ++str;
2912 }
2913
2914 return result;
2915 }
2916
2917 /* Convert a Python string into a Vim line.
2918 *
2919 * The result is in allocated memory. All internal nulls are replaced by
2920 * newline characters. It is an error for the string to contain newline
2921 * characters.
2922 *
2923 * On errors, the Python exception data is set, and NULL is returned.
2924 */
2925 static char *
2926 StringToLine(PyObject *obj)
2927 {
2928 const char *str;
2929 char *save;
2930 PyInt len;
2931 PyInt i;
2932 char *p;
2933
2934 if (obj == NULL || !PyString_Check(obj))
2935 {
2936 PyErr_BadArgument();
2937 return NULL;
2938 }
2939
2940 str = PyString_AsString(obj);
2941 len = PyString_Size(obj);
2942
2943 /*
2944 * Error checking: String must not contain newlines, as we
2945 * are replacing a single line, and we must replace it with
2946 * a single line.
2947 * A trailing newline is removed, so that append(f.readlines()) works.
2948 */
2949 p = memchr(str, '\n', len);
2950 if (p != NULL)
2951 {
2952 if (p == str + len - 1)
2953 --len;
2954 else
2955 {
2956 PyErr_SetVim(_("string cannot contain newlines"));
2957 return NULL;
2958 }
2959 }
2960
2961 /* Create a copy of the string, with internal nulls replaced by
2962 * newline characters, as is the vim convention.
2963 */
2964 save = (char *)alloc((unsigned)(len+1));
2965 if (save == NULL)
2966 {
2967 PyErr_NoMemory();
2968 return NULL;
2969 }
2970
2971 for (i = 0; i < len; ++i)
2972 {
2973 if (str[i] == '\0')
2974 save[i] = '\n';
2975 else
2976 save[i] = str[i];
2977 }
2978
2979 save[i] = '\0';
2980
2981 return save;
2982 }
2983
2984 /* Check to see whether a Vim error has been reported, or a keyboard
2985 * interrupt has been detected.
2986 */
2987 static int
2988 VimErrorCheck(void)
2989 {
2990 if (got_int)
2991 {
2992 PyErr_SetNone(PyExc_KeyboardInterrupt);
2993 return 1;
2994 }
2995 else if (did_emsg && !PyErr_Occurred())
2996 {
2997 PyErr_SetNone(VimError);
2998 return 1;
2999 }
3000
3001 return 0;
3002 }
3003
3004
3005 /* Don't generate a prototype for the next function, it generates an error on
3006 * newer Python versions. */
3007 #if PYTHON_API_VERSION < 1007 /* Python 1.4 */ && !defined(PROTO)
3008
3009 char *
3010 Py_GetProgramName(void)
3011 {
3012 return "vim";
3013 }
3014 #endif /* Python 1.4 */
Vim with various extensions