Mercurial > hg > RemoteEditor > vim7

comparison src/if_python.c @ 0:76efa0be13f1

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