?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Snapshot 44
[MacVim.git] / src / if_python.c
blob9a49dd29f23999955aa055501af4cfb7a743ed6b
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 /*ARGSUSED*/
1100 static PyObject *
1101 VimCommand(PyObject *self, PyObject *args)
1102 {
1103 char *cmd;
1104 PyObject *result;
1105
1106 if (!PyArg_ParseTuple(args, "s", &cmd))
1107 return NULL;
1108
1109 PyErr_Clear();
1110
1111 Py_BEGIN_ALLOW_THREADS
1112 Python_Lock_Vim();
1113
1114 do_cmdline_cmd((char_u *)cmd);
1115 update_screen(VALID);
1116
1117 Python_Release_Vim();
1118 Py_END_ALLOW_THREADS
1119
1120 if (VimErrorCheck())
1121 result = NULL;
1122 else
1123 result = Py_None;
1124
1125 Py_XINCREF(result);
1126 return result;
1127 }
1128
1129 #ifdef FEAT_EVAL
1130 /*
1131 * Function to translate a typval_T into a PyObject; this will recursively
1132 * translate lists/dictionaries into their Python equivalents.
1133 *
1134 * The depth parameter is to avoid infinite recursion, set it to 1 when
1135 * you call VimToPython.
1136 */
1137 static PyObject *
1138 VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
1139 {
1140 PyObject *result;
1141 PyObject *newObj;
1142 char ptrBuf[NUMBUFLEN];
1143
1144 /* Avoid infinite recursion */
1145 if (depth > 100)
1146 {
1147 Py_INCREF(Py_None);
1148 result = Py_None;
1149 return result;
1150 }
1151
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))
1156 {
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);
1161 if (result != NULL)
1162 {
1163 Py_INCREF(result);
1164 return result;
1165 }
1166 }
1167
1168 if (our_tv->v_type == VAR_STRING)
1169 {
1170 result = Py_BuildValue("s", our_tv->vval.v_string);
1171 }
1172 else if (our_tv->v_type == VAR_NUMBER)
1173 {
1174 char buf[NUMBUFLEN];
1175
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);
1179 }
1180 # ifdef FEAT_FLOAT
1181 else if (our_tv->v_type == VAR_FLOAT)
1182 {
1183 char buf[NUMBUFLEN];
1184
1185 sprintf(buf, "%f", our_tv->vval.v_float);
1186 result = Py_BuildValue("s", buf);
1187 }
1188 # endif
1189 else if (our_tv->v_type == VAR_LIST)
1190 {
1191 list_T *list = our_tv->vval.v_list;
1192 listitem_T *curr;
1193
1194 result = PyList_New(0);
1195
1196 if (list != NULL)
1197 {
1198 PyDict_SetItemString(lookupDict, ptrBuf, result);
1199
1200 for (curr = list->lv_first; curr != NULL; curr = curr->li_next)
1201 {
1202 newObj = VimToPython(&curr->li_tv, depth + 1, lookupDict);
1203 PyList_Append(result, newObj);
1204 Py_DECREF(newObj);
1205 }
1206 }
1207 }
1208 else if (our_tv->v_type == VAR_DICT)
1209 {
1210 result = PyDict_New();
1211
1212 if (our_tv->vval.v_dict != NULL)
1213 {
1214 hashtab_T *ht = &our_tv->vval.v_dict->dv_hashtab;
1215 long_u todo = ht->ht_used;
1216 hashitem_T *hi;
1217 dictitem_T *di;
1218
1219 PyDict_SetItemString(lookupDict, ptrBuf, result);
1220
1221 for (hi = ht->ht_array; todo > 0; ++hi)
1222 {
1223 if (!HASHITEM_EMPTY(hi))
1224 {
1225 --todo;
1226
1227 di = dict_lookup(hi);
1228 newObj = VimToPython(&di->di_tv, depth + 1, lookupDict);
1229 PyDict_SetItemString(result, (char *)hi->hi_key, newObj);
1230 Py_DECREF(newObj);
1231 }
1232 }
1233 }
1234 }
1235 else
1236 {
1237 Py_INCREF(Py_None);
1238 result = Py_None;
1239 }
1240
1241 return result;
1242 }
1243 #endif
1244
1245 /*ARGSUSED*/
1246 static PyObject *
1247 VimEval(PyObject *self, PyObject *args)
1248 {
1249 #ifdef FEAT_EVAL
1250 char *expr;
1251 typval_T *our_tv;
1252 PyObject *result;
1253 PyObject *lookup_dict;
1254
1255 if (!PyArg_ParseTuple(args, "s", &expr))
1256 return NULL;
1257
1258 Py_BEGIN_ALLOW_THREADS
1259 Python_Lock_Vim();
1260 our_tv = eval_expr((char_u *)expr, NULL);
1261
1262 Python_Release_Vim();
1263 Py_END_ALLOW_THREADS
1264
1265 if (our_tv == NULL)
1266 {
1267 PyErr_SetVim(_("invalid expression"));
1268 return NULL;
1269 }
1270
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);
1276
1277
1278 Py_BEGIN_ALLOW_THREADS
1279 Python_Lock_Vim();
1280 free_tv(our_tv);
1281 Python_Release_Vim();
1282 Py_END_ALLOW_THREADS
1283
1284 return result;
1285 #else
1286 PyErr_SetVim(_("expressions disabled at compile time"));
1287 return NULL;
1288 #endif
1289 }
1290
1291 /* Common routines for buffers and line ranges
1292 * -------------------------------------------
1293 */
1294 static int
1295 CheckBuffer(BufferObject *this)
1296 {
1297 if (this->buf == INVALID_BUFFER_VALUE)
1298 {
1299 PyErr_SetVim(_("attempt to refer to deleted buffer"));
1300 return -1;
1301 }
1302
1303 return 0;
1304 }
1305
1306 static PyObject *
1307 RBItem(BufferObject *self, PyInt n, PyInt start, PyInt end)
1308 {
1309 if (CheckBuffer(self))
1310 return NULL;
1311
1312 if (n < 0 || n > end - start)
1313 {
1314 PyErr_SetString(PyExc_IndexError, _("line number out of range"));
1315 return NULL;
1316 }
1317
1318 return GetBufferLine(self->buf, n+start);
1319 }
1320
1321 static PyObject *
1322 RBSlice(BufferObject *self, PyInt lo, PyInt hi, PyInt start, PyInt end)
1323 {
1324 PyInt size;
1325
1326 if (CheckBuffer(self))
1327 return NULL;
1328
1329 size = end - start + 1;
1330
1331 if (lo < 0)
1332 lo = 0;
1333 else if (lo > size)
1334 lo = size;
1335 if (hi < 0)
1336 hi = 0;
1337 if (hi < lo)
1338 hi = lo;
1339 else if (hi > size)
1340 hi = size;
1341
1342 return GetBufferLineList(self->buf, lo+start, hi+start);
1343 }
1344
1345 static PyInt
1346 RBAssItem(BufferObject *self, PyInt n, PyObject *val, PyInt start, PyInt end, PyInt *new_end)
1347 {
1348 PyInt len_change;
1349
1350 if (CheckBuffer(self))
1351 return -1;
1352
1353 if (n < 0 || n > end - start)
1354 {
1355 PyErr_SetString(PyExc_IndexError, _("line number out of range"));
1356 return -1;
1357 }
1358
1359 if (SetBufferLine(self->buf, n+start, val, &len_change) == FAIL)
1360 return -1;
1361
1362 if (new_end)
1363 *new_end = end + len_change;
1364
1365 return 0;
1366 }
1367
1368 static PyInt
1369 RBAssSlice(BufferObject *self, PyInt lo, PyInt hi, PyObject *val, PyInt start, PyInt end, PyInt *new_end)
1370 {
1371 PyInt size;
1372 PyInt len_change;
1373
1374 /* Self must be a valid buffer */
1375 if (CheckBuffer(self))
1376 return -1;
1377
1378 /* Sort out the slice range */
1379 size = end - start + 1;
1380
1381 if (lo < 0)
1382 lo = 0;
1383 else if (lo > size)
1384 lo = size;
1385 if (hi < 0)
1386 hi = 0;
1387 if (hi < lo)
1388 hi = lo;
1389 else if (hi > size)
1390 hi = size;
1391
1392 if (SetBufferLineList(self->buf, lo+start, hi+start, val, &len_change) == FAIL)
1393 return -1;
1394
1395 if (new_end)
1396 *new_end = end + len_change;
1397
1398 return 0;
1399 }
1400
1401 static PyObject *
1402 RBAppend(BufferObject *self, PyObject *args, PyInt start, PyInt end, PyInt *new_end)
1403 {
1404 PyObject *lines;
1405 PyInt len_change;
1406 PyInt max;
1407 PyInt n;
1408
1409 if (CheckBuffer(self))
1410 return NULL;
1411
1412 max = n = end - start + 1;
1413
1414 if (!PyArg_ParseTuple(args, "O|" Py_ssize_t_fmt, &lines, &n))
1415 return NULL;
1416
1417 if (n < 0 || n > max)
1418 {
1419 PyErr_SetString(PyExc_ValueError, _("line number out of range"));
1420 return NULL;
1421 }
1422
1423 if (InsertBufferLines(self->buf, n + start - 1, lines, &len_change) == FAIL)
1424 return NULL;
1425
1426 if (new_end)
1427 *new_end = end + len_change;
1428
1429 Py_INCREF(Py_None);
1430 return Py_None;
1431 }
1432
1433
1434 /* Buffer object - Definitions
1435 */
1436
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 }
1443 };
1444
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 */
1453 };
1454
1455 static PyTypeObject BufferType = {
1456 PyObject_HEAD_INIT(0)
1457 0,
1458 "buffer",
1459 sizeof(BufferObject),
1460 0,
1461
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 */
1468
1469 0, /* as number */
1470 &BufferAsSeq, /* as sequence */
1471 0, /* as mapping */
1472
1473 (hashfunc) 0, /* tp_hash, dict(x) */
1474 (ternaryfunc) 0, /* tp_call, x() */
1475 (reprfunc) 0, /* tp_str, str(x) */
1476 };
1477
1478 /* Buffer object - Implementation
1479 */
1480
1481 static PyObject *
1482 BufferNew(buf_T *buf)
1483 {
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.
1496 */
1497
1498 BufferObject *self;
1499
1500 if (buf->b_python_ref != NULL)
1501 {
1502 self = buf->b_python_ref;
1503 Py_INCREF(self);
1504 }
1505 else
1506 {
1507 self = PyObject_NEW(BufferObject, &BufferType);
1508 if (self == NULL)
1509 return NULL;
1510 self->buf = buf;
1511 buf->b_python_ref = self;
1512 }
1513
1514 return (PyObject *)(self);
1515 }
1516
1517 static void
1518 BufferDestructor(PyObject *self)
1519 {
1520 BufferObject *this = (BufferObject *)(self);
1521
1522 if (this->buf && this->buf != INVALID_BUFFER_VALUE)
1523 this->buf->b_python_ref = NULL;
1524
1525 Py_DECREF(self);
1526 }
1527
1528 static PyObject *
1529 BufferGetattr(PyObject *self, char *name)
1530 {
1531 BufferObject *this = (BufferObject *)(self);
1532
1533 if (CheckBuffer(this))
1534 return NULL;
1535
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");
1542 else
1543 return Py_FindMethod(BufferMethods, self, name);
1544 }
1545
1546 static PyObject *
1547 BufferRepr(PyObject *self)
1548 {
1549 static char repr[100];
1550 BufferObject *this = (BufferObject *)(self);
1551
1552 if (this->buf == INVALID_BUFFER_VALUE)
1553 {
1554 vim_snprintf(repr, 100, _("<buffer object (deleted) at %p>"), (self));
1555 return PyString_FromString(repr);
1556 }
1557 else
1558 {
1559 char *name = (char *)this->buf->b_fname;
1560 PyInt len;
1561
1562 if (name == NULL)
1563 name = "";
1564 len = strlen(name);
1565
1566 if (len > 35)
1567 name = name + (35 - len);
1568
1569 vim_snprintf(repr, 100, "<buffer %s%s>", len > 35 ? "..." : "", name);
1570
1571 return PyString_FromString(repr);
1572 }
1573 }
1574
1575 /******************/
1576
1577 static PyInt
1578 BufferLength(PyObject *self)
1579 {
1580 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
1581 if (CheckBuffer((BufferObject *)(self)))
1582 return -1; /* ??? */
1583
1584 return (((BufferObject *)(self))->buf->b_ml.ml_line_count);
1585 }
1586
1587 static PyObject *
1588 BufferItem(PyObject *self, PyInt n)
1589 {
1590 return RBItem((BufferObject *)(self), n, 1,
1591 (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);
1592 }
1593
1594 static PyObject *
1595 BufferSlice(PyObject *self, PyInt lo, PyInt hi)
1596 {
1597 return RBSlice((BufferObject *)(self), lo, hi, 1,
1598 (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);
1599 }
1600
1601 static PyInt
1602 BufferAssItem(PyObject *self, PyInt n, PyObject *val)
1603 {
1604 return RBAssItem((BufferObject *)(self), n, val, 1,
1605 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1606 NULL);
1607 }
1608
1609 static PyInt
1610 BufferAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
1611 {
1612 return RBAssSlice((BufferObject *)(self), lo, hi, val, 1,
1613 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1614 NULL);
1615 }
1616
1617 static PyObject *
1618 BufferAppend(PyObject *self, PyObject *args)
1619 {
1620 return RBAppend((BufferObject *)(self), args, 1,
1621 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
1622 NULL);
1623 }
1624
1625 static PyObject *
1626 BufferMark(PyObject *self, PyObject *args)
1627 {
1628 pos_T *posp;
1629 char mark;
1630 buf_T *curbuf_save;
1631
1632 if (CheckBuffer((BufferObject *)(self)))
1633 return NULL;
1634
1635 if (!PyArg_ParseTuple(args, "c", &mark))
1636 return NULL;
1637
1638 curbuf_save = curbuf;
1639 curbuf = ((BufferObject *)(self))->buf;
1640 posp = getmark(mark, FALSE);
1641 curbuf = curbuf_save;
1642
1643 if (posp == NULL)
1644 {
1645 PyErr_SetVim(_("invalid mark name"));
1646 return NULL;
1647 }
1648
1649 /* Ckeck for keyboard interrupt */
1650 if (VimErrorCheck())
1651 return NULL;
1652
1653 if (posp->lnum <= 0)
1654 {
1655 /* Or raise an error? */
1656 Py_INCREF(Py_None);
1657 return Py_None;
1658 }
1659
1660 return Py_BuildValue("(ll)", (long)(posp->lnum), (long)(posp->col));
1661 }
1662
1663 static PyObject *
1664 BufferRange(PyObject *self, PyObject *args)
1665 {
1666 PyInt start;
1667 PyInt end;
1668
1669 if (CheckBuffer((BufferObject *)(self)))
1670 return NULL;
1671
1672 if (!PyArg_ParseTuple(args, Py_ssize_t_fmt Py_ssize_t_fmt, &start, &end))
1673 return NULL;
1674
1675 return RangeNew(((BufferObject *)(self))->buf, start, end);
1676 }
1677
1678 /* Line range object - Definitions
1679 */
1680
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 }
1685 };
1686
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 */
1695 };
1696
1697 static PyTypeObject RangeType = {
1698 PyObject_HEAD_INIT(0)
1699 0,
1700 "range",
1701 sizeof(RangeObject),
1702 0,
1703
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 */
1710
1711 0, /* as number */
1712 &RangeAsSeq, /* as sequence */
1713 0, /* as mapping */
1714
1715 (hashfunc) 0, /* tp_hash, dict(x) */
1716 (ternaryfunc) 0, /* tp_call, x() */
1717 (reprfunc) 0, /* tp_str, str(x) */
1718 };
1719
1720 /* Line range object - Implementation
1721 */
1722
1723 static PyObject *
1724 RangeNew(buf_T *buf, PyInt start, PyInt end)
1725 {
1726 BufferObject *bufr;
1727 RangeObject *self;
1728 self = PyObject_NEW(RangeObject, &RangeType);
1729 if (self == NULL)
1730 return NULL;
1731
1732 bufr = (BufferObject *)BufferNew(buf);
1733 if (bufr == NULL)
1734 {
1735 Py_DECREF(self);
1736 return NULL;
1737 }
1738 Py_INCREF(bufr);
1739
1740 self->buf = bufr;
1741 self->start = start;
1742 self->end = end;
1743
1744 return (PyObject *)(self);
1745 }
1746
1747 static void
1748 RangeDestructor(PyObject *self)
1749 {
1750 Py_DECREF(((RangeObject *)(self))->buf);
1751 Py_DECREF(self);
1752 }
1753
1754 static PyObject *
1755 RangeGetattr(PyObject *self, char *name)
1756 {
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);
1761 else
1762 return Py_FindMethod(RangeMethods, self, name);
1763 }
1764
1765 static PyObject *
1766 RangeRepr(PyObject *self)
1767 {
1768 static char repr[100];
1769 RangeObject *this = (RangeObject *)(self);
1770
1771 if (this->buf->buf == INVALID_BUFFER_VALUE)
1772 {
1773 vim_snprintf(repr, 100, "<range object (for deleted buffer) at %p>",
1774 (self));
1775 return PyString_FromString(repr);
1776 }
1777 else
1778 {
1779 char *name = (char *)this->buf->buf->b_fname;
1780 int len;
1781
1782 if (name == NULL)
1783 name = "";
1784 len = (int)strlen(name);
1785
1786 if (len > 45)
1787 name = name + (45 - len);
1788
1789 vim_snprintf(repr, 100, "<range %s%s (%d:%d)>",
1790 len > 45 ? "..." : "", name,
1791 this->start, this->end);
1792
1793 return PyString_FromString(repr);
1794 }
1795 }
1796
1797 /****************/
1798
1799 static PyInt
1800 RangeLength(PyObject *self)
1801 {
1802 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
1803 if (CheckBuffer(((RangeObject *)(self))->buf))
1804 return -1; /* ??? */
1805
1806 return (((RangeObject *)(self))->end - ((RangeObject *)(self))->start + 1);
1807 }
1808
1809 static PyObject *
1810 RangeItem(PyObject *self, PyInt n)
1811 {
1812 return RBItem(((RangeObject *)(self))->buf, n,
1813 ((RangeObject *)(self))->start,
1814 ((RangeObject *)(self))->end);
1815 }
1816
1817 static PyObject *
1818 RangeSlice(PyObject *self, PyInt lo, PyInt hi)
1819 {
1820 return RBSlice(((RangeObject *)(self))->buf, lo, hi,
1821 ((RangeObject *)(self))->start,
1822 ((RangeObject *)(self))->end);
1823 }
1824
1825 static PyInt
1826 RangeAssItem(PyObject *self, PyInt n, PyObject *val)
1827 {
1828 return RBAssItem(((RangeObject *)(self))->buf, n, val,
1829 ((RangeObject *)(self))->start,
1830 ((RangeObject *)(self))->end,
1831 &((RangeObject *)(self))->end);
1832 }
1833
1834 static PyInt
1835 RangeAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
1836 {
1837 return RBAssSlice(((RangeObject *)(self))->buf, lo, hi, val,
1838 ((RangeObject *)(self))->start,
1839 ((RangeObject *)(self))->end,
1840 &((RangeObject *)(self))->end);
1841 }
1842
1843 static PyObject *
1844 RangeAppend(PyObject *self, PyObject *args)
1845 {
1846 return RBAppend(((RangeObject *)(self))->buf, args,
1847 ((RangeObject *)(self))->start,
1848 ((RangeObject *)(self))->end,
1849 &((RangeObject *)(self))->end);
1850 }
1851
1852 /* Buffer list object - Definitions
1853 */
1854
1855 typedef struct
1856 {
1857 PyObject_HEAD
1858 }
1859 BufListObject;
1860
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 */
1869 };
1870
1871 static PyTypeObject BufListType = {
1872 PyObject_HEAD_INIT(0)
1873 0,
1874 "buffer list",
1875 sizeof(BufListObject),
1876 0,
1877
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 */
1884
1885 0, /* as number */
1886 &BufListAsSeq, /* as sequence */
1887 0, /* as mapping */
1888
1889 (hashfunc) 0, /* tp_hash, dict(x) */
1890 (ternaryfunc) 0, /* tp_call, x() */
1891 (reprfunc) 0, /* tp_str, str(x) */
1892 };
1893
1894 /* Buffer list object - Implementation
1895 */
1896
1897 /*ARGSUSED*/
1898 static PyInt
1899 BufListLength(PyObject *self)
1900 {
1901 buf_T *b = firstbuf;
1902 PyInt n = 0;
1903
1904 while (b)
1905 {
1906 ++n;
1907 b = b->b_next;
1908 }
1909
1910 return n;
1911 }
1912
1913 /*ARGSUSED*/
1914 static PyObject *
1915 BufListItem(PyObject *self, PyInt n)
1916 {
1917 buf_T *b;
1918
1919 for (b = firstbuf; b; b = b->b_next, --n)
1920 {
1921 if (n == 0)
1922 return BufferNew(b);
1923 }
1924
1925 PyErr_SetString(PyExc_IndexError, _("no such buffer"));
1926 return NULL;
1927 }
1928
1929 /* Window object - Definitions
1930 */
1931
1932 static struct PyMethodDef WindowMethods[] = {
1933 /* name, function, calling, documentation */
1934 { NULL, NULL, 0, NULL }
1935 };
1936
1937 static PyTypeObject WindowType = {
1938 PyObject_HEAD_INIT(0)
1939 0,
1940 "window",
1941 sizeof(WindowObject),
1942 0,
1943
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 */
1950
1951 0, /* as number */
1952 0, /* as sequence */
1953 0, /* as mapping */
1954
1955 (hashfunc) 0, /* tp_hash, dict(x) */
1956 (ternaryfunc) 0, /* tp_call, x() */
1957 (reprfunc) 0, /* tp_str, str(x) */
1958 };
1959
1960 /* Window object - Implementation
1961 */
1962
1963 static PyObject *
1964 WindowNew(win_T *win)
1965 {
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.
1976 */
1977
1978 WindowObject *self;
1979
1980 if (win->w_python_ref)
1981 {
1982 self = win->w_python_ref;
1983 Py_INCREF(self);
1984 }
1985 else
1986 {
1987 self = PyObject_NEW(WindowObject, &WindowType);
1988 if (self == NULL)
1989 return NULL;
1990 self->win = win;
1991 win->w_python_ref = self;
1992 }
1993
1994 return (PyObject *)(self);
1995 }
1996
1997 static void
1998 WindowDestructor(PyObject *self)
1999 {
2000 WindowObject *this = (WindowObject *)(self);
2001
2002 if (this->win && this->win != INVALID_WINDOW_VALUE)
2003 this->win->w_python_ref = NULL;
2004
2005 Py_DECREF(self);
2006 }
2007
2008 static int
2009 CheckWindow(WindowObject *this)
2010 {
2011 if (this->win == INVALID_WINDOW_VALUE)
2012 {
2013 PyErr_SetVim(_("attempt to refer to deleted window"));
2014 return -1;
2015 }
2016
2017 return 0;
2018 }
2019
2020 static PyObject *
2021 WindowGetattr(PyObject *self, char *name)
2022 {
2023 WindowObject *this = (WindowObject *)(self);
2024
2025 if (CheckWindow(this))
2026 return NULL;
2027
2028 if (strcmp(name, "buffer") == 0)
2029 return (PyObject *)BufferNew(this->win->w_buffer);
2030 else if (strcmp(name, "cursor") == 0)
2031 {
2032 pos_T *pos = &this->win->w_cursor;
2033
2034 return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));
2035 }
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)));
2041 #endif
2042 else if (strcmp(name,"__members__") == 0)
2043 return Py_BuildValue("[sss]", "buffer", "cursor", "height");
2044 else
2045 return Py_FindMethod(WindowMethods, self, name);
2046 }
2047
2048 static int
2049 WindowSetattr(PyObject *self, char *name, PyObject *val)
2050 {
2051 WindowObject *this = (WindowObject *)(self);
2052
2053 if (CheckWindow(this))
2054 return -1;
2055
2056 if (strcmp(name, "buffer") == 0)
2057 {
2058 PyErr_SetString(PyExc_TypeError, _("readonly attribute"));
2059 return -1;
2060 }
2061 else if (strcmp(name, "cursor") == 0)
2062 {
2063 long lnum;
2064 long col;
2065
2066 if (!PyArg_Parse(val, "(ll)", &lnum, &col))
2067 return -1;
2068
2069 if (lnum <= 0 || lnum > this->win->w_buffer->b_ml.ml_line_count)
2070 {
2071 PyErr_SetVim(_("cursor position outside buffer"));
2072 return -1;
2073 }
2074
2075 /* Check for keyboard interrupts */
2076 if (VimErrorCheck())
2077 return -1;
2078
2079 /* NO CHECK ON COLUMN - SEEMS NOT TO MATTER */
2080
2081 this->win->w_cursor.lnum = lnum;
2082 this->win->w_cursor.col = col;
2083 update_screen(VALID);
2084
2085 return 0;
2086 }
2087 else if (strcmp(name, "height") == 0)
2088 {
2089 int height;
2090 win_T *savewin;
2091
2092 if (!PyArg_Parse(val, "i", &height))
2093 return -1;
2094
2095 #ifdef FEAT_GUI
2096 need_mouse_correct = TRUE;
2097 #endif
2098 savewin = curwin;
2099 curwin = this->win;
2100 win_setheight(height);
2101 curwin = savewin;
2102
2103 /* Check for keyboard interrupts */
2104 if (VimErrorCheck())
2105 return -1;
2106
2107 return 0;
2108 }
2109 #ifdef FEAT_VERTSPLIT
2110 else if (strcmp(name, "width") == 0)
2111 {
2112 int width;
2113 win_T *savewin;
2114
2115 if (!PyArg_Parse(val, "i", &width))
2116 return -1;
2117
2118 #ifdef FEAT_GUI
2119 need_mouse_correct = TRUE;
2120 #endif
2121 savewin = curwin;
2122 curwin = this->win;
2123 win_setwidth(width);
2124 curwin = savewin;
2125
2126 /* Check for keyboard interrupts */
2127 if (VimErrorCheck())
2128 return -1;
2129
2130 return 0;
2131 }
2132 #endif
2133 else
2134 {
2135 PyErr_SetString(PyExc_AttributeError, name);
2136 return -1;
2137 }
2138 }
2139
2140 static PyObject *
2141 WindowRepr(PyObject *self)
2142 {
2143 static char repr[100];
2144 WindowObject *this = (WindowObject *)(self);
2145
2146 if (this->win == INVALID_WINDOW_VALUE)
2147 {
2148 vim_snprintf(repr, 100, _("<window object (deleted) at %p>"), (self));
2149 return PyString_FromString(repr);
2150 }
2151 else
2152 {
2153 int i = 0;
2154 win_T *w;
2155
2156 for (w = firstwin; w != NULL && w != this->win; w = W_NEXT(w))
2157 ++i;
2158
2159 if (w == NULL)
2160 vim_snprintf(repr, 100, _("<window object (unknown) at %p>"),
2161 (self));
2162 else
2163 vim_snprintf(repr, 100, _("<window %d>"), i);
2164
2165 return PyString_FromString(repr);
2166 }
2167 }
2168
2169 /* Window list object - Definitions
2170 */
2171
2172 typedef struct
2173 {
2174 PyObject_HEAD
2175 }
2176 WinListObject;
2177
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 */
2186 };
2187
2188 static PyTypeObject WinListType = {
2189 PyObject_HEAD_INIT(0)
2190 0,
2191 "window list",
2192 sizeof(WinListObject),
2193 0,
2194
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 */
2201
2202 0, /* as number */
2203 &WinListAsSeq, /* as sequence */
2204 0, /* as mapping */
2205
2206 (hashfunc) 0, /* tp_hash, dict(x) */
2207 (ternaryfunc) 0, /* tp_call, x() */
2208 (reprfunc) 0, /* tp_str, str(x) */
2209 };
2210
2211 /* Window list object - Implementation
2212 */
2213 /*ARGSUSED*/
2214 static PyInt
2215 WinListLength(PyObject *self)
2216 {
2217 win_T *w = firstwin;
2218 PyInt n = 0;
2219
2220 while (w != NULL)
2221 {
2222 ++n;
2223 w = W_NEXT(w);
2224 }
2225
2226 return n;
2227 }
2228
2229 /*ARGSUSED*/
2230 static PyObject *
2231 WinListItem(PyObject *self, PyInt n)
2232 {
2233 win_T *w;
2234
2235 for (w = firstwin; w != NULL; w = W_NEXT(w), --n)
2236 if (n == 0)
2237 return WindowNew(w);
2238
2239 PyErr_SetString(PyExc_IndexError, _("no such window"));
2240 return NULL;
2241 }
2242
2243 /* Current items object - Definitions
2244 */
2245
2246 typedef struct
2247 {
2248 PyObject_HEAD
2249 }
2250 CurrentObject;
2251
2252 static PyTypeObject CurrentType = {
2253 PyObject_HEAD_INIT(0)
2254 0,
2255 "current data",
2256 sizeof(CurrentObject),
2257 0,
2258
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 */
2265
2266 0, /* as number */
2267 0, /* as sequence */
2268 0, /* as mapping */
2269
2270 (hashfunc) 0, /* tp_hash, dict(x) */
2271 (ternaryfunc) 0, /* tp_call, x() */
2272 (reprfunc) 0, /* tp_str, str(x) */
2273 };
2274
2275 /* Current items object - Implementation
2276 */
2277 /*ARGSUSED*/
2278 static PyObject *
2279 CurrentGetattr(PyObject *self, 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 /*ARGSUSED*/
2299 static int
2300 CurrentSetattr(PyObject *self, char *name, PyObject *value)
2301 {
2302 if (strcmp(name, "line") == 0)
2303 {
2304 if (SetBufferLine(curbuf, (PyInt)curwin->w_cursor.lnum, value, NULL) == FAIL)
2305 return -1;
2306
2307 return 0;
2308 }
2309 else
2310 {
2311 PyErr_SetString(PyExc_AttributeError, name);
2312 return -1;
2313 }
2314 }
2315
2316 /* External interface
2317 */
2318
2319 void
2320 python_buffer_free(buf_T *buf)
2321 {
2322 if (buf->b_python_ref != NULL)
2323 {
2324 BufferObject *bp = buf->b_python_ref;
2325 bp->buf = INVALID_BUFFER_VALUE;
2326 buf->b_python_ref = NULL;
2327 }
2328 }
2329
2330 #if defined(FEAT_WINDOWS) || defined(PROTO)
2331 void
2332 python_window_free(win_T *win)
2333 {
2334 if (win->w_python_ref != NULL)
2335 {
2336 WindowObject *wp = win->w_python_ref;
2337 wp->win = INVALID_WINDOW_VALUE;
2338 win->w_python_ref = NULL;
2339 }
2340 }
2341 #endif
2342
2343 static BufListObject TheBufferList =
2344 {
2345 PyObject_HEAD_INIT(&BufListType)
2346 };
2347
2348 static WinListObject TheWindowList =
2349 {
2350 PyObject_HEAD_INIT(&WinListType)
2351 };
2352
2353 static CurrentObject TheCurrent =
2354 {
2355 PyObject_HEAD_INIT(&CurrentType)
2356 };
2357
2358 static int
2359 PythonMod_Init(void)
2360 {
2361 PyObject *mod;
2362 PyObject *dict;
2363 /* The special value is removed from sys.path in Python_Init(). */
2364 static char *(argv[2]) = {"/must>not&exist/foo", NULL};
2365
2366 /* Fixups... */
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;
2373
2374 /* Set sys.argv[] to avoid a crash in warn(). */
2375 PySys_SetArgv(1, argv);
2376
2377 mod = Py_InitModule4("vim", VimMethods, (char *)NULL, (PyObject *)NULL, PYTHON_API_VERSION);
2378 dict = PyModule_GetDict(mod);
2379
2380 VimError = Py_BuildValue("s", "vim.error");
2381
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);
2386
2387 if (PyErr_Occurred())
2388 return -1;
2389
2390 return 0;
2391 }
2392
2393 /*************************************************************************
2394 * 4. Utility functions for handling the interface between Vim and Python.
2395 */
2396
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
2399 * string object.
2400 */
2401 static PyObject *
2402 GetBufferLine(buf_T *buf, PyInt n)
2403 {
2404 return LineToString((char *)ml_get_buf(buf, (linenr_T)n, FALSE));
2405 }
2406
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.
2410 */
2411 static PyObject *
2412 GetBufferLineList(buf_T *buf, PyInt lo, PyInt hi)
2413 {
2414 PyInt i;
2415 PyInt n = hi - lo;
2416 PyObject *list = PyList_New(n);
2417
2418 if (list == NULL)
2419 return NULL;
2420
2421 for (i = 0; i < n; ++i)
2422 {
2423 PyObject *str = LineToString((char *)ml_get_buf(buf, (linenr_T)(lo+i), FALSE));
2424
2425 /* Error check - was the Python string creation OK? */
2426 if (str == NULL)
2427 {
2428 Py_DECREF(list);
2429 return NULL;
2430 }
2431
2432 /* Set the list item */
2433 if (PyList_SetItem(list, i, str))
2434 {
2435 Py_DECREF(str);
2436 Py_DECREF(list);
2437 return NULL;
2438 }
2439 }
2440
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
2443 * with it).
2444 */
2445
2446 return list;
2447 }
2448
2449 /*
2450 * Check if deleting lines made the cursor position invalid.
2451 * Changed the lines from "lo" to "hi" and added "extra" lines (negative if
2452 * deleted).
2453 */
2454 static void
2455 py_fix_cursor(linenr_T lo, linenr_T hi, linenr_T extra)
2456 {
2457 if (curwin->w_cursor.lnum >= lo)
2458 {
2459 /* Adjust the cursor position if it's in/after the changed
2460 * lines. */
2461 if (curwin->w_cursor.lnum >= hi)
2462 {
2463 curwin->w_cursor.lnum += extra;
2464 check_cursor_col();
2465 }
2466 else if (extra < 0)
2467 {
2468 curwin->w_cursor.lnum = lo;
2469 check_cursor();
2470 }
2471 else
2472 check_cursor_col();
2473 changed_cline_bef_curs();
2474 }
2475 invalidate_botline();
2476 }
2477
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.
2485 */
2486 static int
2487 SetBufferLine(buf_T *buf, PyInt n, PyObject *line, PyInt *len_change)
2488 {
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.
2494 */
2495 if (line == Py_None || line == NULL)
2496 {
2497 buf_T *savebuf = curbuf;
2498
2499 PyErr_Clear();
2500 curbuf = buf;
2501
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"));
2506 else
2507 {
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);
2511 }
2512
2513 curbuf = savebuf;
2514
2515 if (PyErr_Occurred() || VimErrorCheck())
2516 return FAIL;
2517
2518 if (len_change)
2519 *len_change = -1;
2520
2521 return OK;
2522 }
2523 else if (PyString_Check(line))
2524 {
2525 char *save = StringToLine(line);
2526 buf_T *savebuf = curbuf;
2527
2528 if (save == NULL)
2529 return FAIL;
2530
2531 /* We do not need to free "save" if ml_replace() consumes it. */
2532 PyErr_Clear();
2533 curbuf = buf;
2534
2535 if (u_savesub((linenr_T)n) == FAIL)
2536 {
2537 PyErr_SetVim(_("cannot save undo information"));
2538 vim_free(save);
2539 }
2540 else if (ml_replace((linenr_T)n, (char_u *)save, FALSE) == FAIL)
2541 {
2542 PyErr_SetVim(_("cannot replace line"));
2543 vim_free(save);
2544 }
2545 else
2546 changed_bytes((linenr_T)n, 0);
2547
2548 curbuf = savebuf;
2549
2550 /* Check that the cursor is not beyond the end of the line now. */
2551 if (buf == curwin->w_buffer)
2552 check_cursor_col();
2553
2554 if (PyErr_Occurred() || VimErrorCheck())
2555 return FAIL;
2556
2557 if (len_change)
2558 *len_change = 0;
2559
2560 return OK;
2561 }
2562 else
2563 {
2564 PyErr_BadArgument();
2565 return FAIL;
2566 }
2567 }
2568
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.
2576 */
2577 static int
2578 SetBufferLineList(buf_T *buf, PyInt lo, PyInt hi, PyObject *list, PyInt *len_change)
2579 {
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.
2585 */
2586 if (list == Py_None || list == NULL)
2587 {
2588 PyInt i;
2589 PyInt n = (int)(hi - lo);
2590 buf_T *savebuf = curbuf;
2591
2592 PyErr_Clear();
2593 curbuf = buf;
2594
2595 if (u_savedel((linenr_T)lo, (long)n) == FAIL)
2596 PyErr_SetVim(_("cannot save undo information"));
2597 else
2598 {
2599 for (i = 0; i < n; ++i)
2600 {
2601 if (ml_delete((linenr_T)lo, FALSE) == FAIL)
2602 {
2603 PyErr_SetVim(_("cannot delete line"));
2604 break;
2605 }
2606 }
2607 deleted_lines_mark((linenr_T)lo, (long)i);
2608
2609 if (buf == curwin->w_buffer)
2610 py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)-n);
2611 }
2612
2613 curbuf = savebuf;
2614
2615 if (PyErr_Occurred() || VimErrorCheck())
2616 return FAIL;
2617
2618 if (len_change)
2619 *len_change = -n;
2620
2621 return OK;
2622 }
2623 else if (PyList_Check(list))
2624 {
2625 PyInt i;
2626 PyInt new_len = PyList_Size(list);
2627 PyInt old_len = hi - lo;
2628 PyInt extra = 0; /* lines added to text, can be negative */
2629 char **array;
2630 buf_T *savebuf;
2631
2632 if (new_len == 0) /* avoid allocating zero bytes */
2633 array = NULL;
2634 else
2635 {
2636 array = (char **)alloc((unsigned)(new_len * sizeof(char *)));
2637 if (array == NULL)
2638 {
2639 PyErr_NoMemory();
2640 return FAIL;
2641 }
2642 }
2643
2644 for (i = 0; i < new_len; ++i)
2645 {
2646 PyObject *line = PyList_GetItem(list, i);
2647
2648 array[i] = StringToLine(line);
2649 if (array[i] == NULL)
2650 {
2651 while (i)
2652 vim_free(array[--i]);
2653 vim_free(array);
2654 return FAIL;
2655 }
2656 }
2657
2658 savebuf = curbuf;
2659
2660 PyErr_Clear();
2661 curbuf = buf;
2662
2663 if (u_save((linenr_T)(lo-1), (linenr_T)hi) == FAIL)
2664 PyErr_SetVim(_("cannot save undo information"));
2665
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".
2669 */
2670 if (!PyErr_Occurred())
2671 {
2672 for (i = 0; i < old_len - new_len; ++i)
2673 if (ml_delete((linenr_T)lo, FALSE) == FAIL)
2674 {
2675 PyErr_SetVim(_("cannot delete line"));
2676 break;
2677 }
2678 extra -= i;
2679 }
2680
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.
2684 */
2685 if (!PyErr_Occurred())
2686 {
2687 for (i = 0; i < old_len && i < new_len; ++i)
2688 if (ml_replace((linenr_T)(lo+i), (char_u *)array[i], FALSE)
2689 == FAIL)
2690 {
2691 PyErr_SetVim(_("cannot replace line"));
2692 break;
2693 }
2694 }
2695 else
2696 i = 0;
2697
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).
2701 */
2702 if (!PyErr_Occurred())
2703 {
2704 while (i < new_len)
2705 {
2706 if (ml_append((linenr_T)(lo + i - 1),
2707 (char_u *)array[i], 0, FALSE) == FAIL)
2708 {
2709 PyErr_SetVim(_("cannot insert line"));
2710 break;
2711 }
2712 vim_free(array[i]);
2713 ++i;
2714 ++extra;
2715 }
2716 }
2717
2718 /* Free any left-over old_len, as a result of an error */
2719 while (i < new_len)
2720 {
2721 vim_free(array[i]);
2722 ++i;
2723 }
2724
2725 /* Free the array of old_len. All of its contents have now
2726 * been dealt with (either freed, or the responsibility passed
2727 * to vim.
2728 */
2729 vim_free(array);
2730
2731 /* Adjust marks. Invalidate any which lie in the
2732 * changed range, and move any in the remainder of the buffer.
2733 */
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);
2737
2738 if (buf == curwin->w_buffer)
2739 py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)extra);
2740
2741 curbuf = savebuf;
2742
2743 if (PyErr_Occurred() || VimErrorCheck())
2744 return FAIL;
2745
2746 if (len_change)
2747 *len_change = new_len - old_len;
2748
2749 return OK;
2750 }
2751 else
2752 {
2753 PyErr_BadArgument();
2754 return FAIL;
2755 }
2756 }
2757
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.
2765 */
2766 static int
2767 InsertBufferLines(buf_T *buf, PyInt n, PyObject *lines, PyInt *len_change)
2768 {
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.
2771 */
2772 if (PyString_Check(lines))
2773 {
2774 char *str = StringToLine(lines);
2775 buf_T *savebuf;
2776
2777 if (str == NULL)
2778 return FAIL;
2779
2780 savebuf = curbuf;
2781
2782 PyErr_Clear();
2783 curbuf = buf;
2784
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"));
2789 else
2790 appended_lines_mark((linenr_T)n, 1L);
2791
2792 vim_free(str);
2793 curbuf = savebuf;
2794 update_screen(VALID);
2795
2796 if (PyErr_Occurred() || VimErrorCheck())
2797 return FAIL;
2798
2799 if (len_change)
2800 *len_change = 1;
2801
2802 return OK;
2803 }
2804 else if (PyList_Check(lines))
2805 {
2806 PyInt i;
2807 PyInt size = PyList_Size(lines);
2808 char **array;
2809 buf_T *savebuf;
2810
2811 array = (char **)alloc((unsigned)(size * sizeof(char *)));
2812 if (array == NULL)
2813 {
2814 PyErr_NoMemory();
2815 return FAIL;
2816 }
2817
2818 for (i = 0; i < size; ++i)
2819 {
2820 PyObject *line = PyList_GetItem(lines, i);
2821 array[i] = StringToLine(line);
2822
2823 if (array[i] == NULL)
2824 {
2825 while (i)
2826 vim_free(array[--i]);
2827 vim_free(array);
2828 return FAIL;
2829 }
2830 }
2831
2832 savebuf = curbuf;
2833
2834 PyErr_Clear();
2835 curbuf = buf;
2836
2837 if (u_save((linenr_T)n, (linenr_T)(n + 1)) == FAIL)
2838 PyErr_SetVim(_("cannot save undo information"));
2839 else
2840 {
2841 for (i = 0; i < size; ++i)
2842 {
2843 if (ml_append((linenr_T)(n + i),
2844 (char_u *)array[i], 0, FALSE) == FAIL)
2845 {
2846 PyErr_SetVim(_("cannot insert line"));
2847
2848 /* Free the rest of the lines */
2849 while (i < size)
2850 vim_free(array[i++]);
2851
2852 break;
2853 }
2854 vim_free(array[i]);
2855 }
2856 if (i > 0)
2857 appended_lines_mark((linenr_T)n, (long)i);
2858 }
2859
2860 /* Free the array of lines. All of its contents have now
2861 * been freed.
2862 */
2863 vim_free(array);
2864
2865 curbuf = savebuf;
2866 update_screen(VALID);
2867
2868 if (PyErr_Occurred() || VimErrorCheck())
2869 return FAIL;
2870
2871 if (len_change)
2872 *len_change = size;
2873
2874 return OK;
2875 }
2876 else
2877 {
2878 PyErr_BadArgument();
2879 return FAIL;
2880 }
2881 }
2882
2883 /* Convert a Vim line into a Python string.
2884 * All internal newlines are replaced by null characters.
2885 *
2886 * On errors, the Python exception data is set, and NULL is returned.
2887 */
2888 static PyObject *
2889 LineToString(const char *str)
2890 {
2891 PyObject *result;
2892 PyInt len = strlen(str);
2893 char *p;
2894
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.
2898 */
2899 result = PyString_FromStringAndSize(NULL, len);
2900 if (result == NULL)
2901 return NULL;
2902
2903 p = PyString_AsString(result);
2904
2905 while (*str)
2906 {
2907 if (*str == '\n')
2908 *p = '\0';
2909 else
2910 *p = *str;
2911
2912 ++p;
2913 ++str;
2914 }
2915
2916 return result;
2917 }
2918
2919 /* Convert a Python string into a Vim line.
2920 *
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
2923 * characters.
2924 *
2925 * On errors, the Python exception data is set, and NULL is returned.
2926 */
2927 static char *
2928 StringToLine(PyObject *obj)
2929 {
2930 const char *str;
2931 char *save;
2932 PyInt len;
2933 PyInt i;
2934 char *p;
2935
2936 if (obj == NULL || !PyString_Check(obj))
2937 {
2938 PyErr_BadArgument();
2939 return NULL;
2940 }
2941
2942 str = PyString_AsString(obj);
2943 len = PyString_Size(obj);
2944
2945 /*
2946 * Error checking: String must not contain newlines, as we
2947 * are replacing a single line, and we must replace it with
2948 * a single line.
2949 * A trailing newline is removed, so that append(f.readlines()) works.
2950 */
2951 p = memchr(str, '\n', len);
2952 if (p != NULL)
2953 {
2954 if (p == str + len - 1)
2955 --len;
2956 else
2957 {
2958 PyErr_SetVim(_("string cannot contain newlines"));
2959 return NULL;
2960 }
2961 }
2962
2963 /* Create a copy of the string, with internal nulls replaced by
2964 * newline characters, as is the vim convention.
2965 */
2966 save = (char *)alloc((unsigned)(len+1));
2967 if (save == NULL)
2968 {
2969 PyErr_NoMemory();
2970 return NULL;
2971 }
2972
2973 for (i = 0; i < len; ++i)
2974 {
2975 if (str[i] == '\0')
2976 save[i] = '\n';
2977 else
2978 save[i] = str[i];
2979 }
2980
2981 save[i] = '\0';
2982
2983 return save;
2984 }
2985
2986 /* Check to see whether a Vim error has been reported, or a keyboard
2987 * interrupt has been detected.
2988 */
2989 static int
2990 VimErrorCheck(void)
2991 {
2992 if (got_int)
2993 {
2994 PyErr_SetNone(PyExc_KeyboardInterrupt);
2995 return 1;
2996 }
2997 else if (did_emsg && !PyErr_Occurred())
2998 {
2999 PyErr_SetNone(VimError);
3000 return 1;
3001 }
3002
3003 return 0;
3004 }
3005
3006
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)
3010
3011 char *
3012 Py_GetProgramName(void)
3013 {
3014 return "vim";
3015 }
3016 #endif /* Python 1.4 */
Vim for the Mac