Mercurial > vim
view src/if_py_both.h @ 19219:89931701e033 v8.2.0168
patch 8.2.0168: Coverity warning for assigning NULL to an option
Commit: https://github.com/vim/vim/commit/97a2af39cd3249c6cbe5a5c59bc24167632d39ad
Author: Bram Moolenaar <Bram@vim.org>
Date: Tue Jan 28 22:52:48 2020 +0100
patch 8.2.0168: Coverity warning for assigning NULL to an option
Problem: Coverity warning for assigning NULL to an option.
Solution: Use empty string instead of NULL.
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Tue, 28 Jan 2020 23:00:04 +0100 |
parents | 9f98957582d6 |
children | d776967d0f0d |
line wrap: on
line source
/* vi:set ts=8 sts=4 sw=4 noet: * * VIM - Vi IMproved by Bram Moolenaar * * Do ":help uganda" in Vim to read copying and usage conditions. * Do ":help credits" in Vim to see a list of people who contributed. * See README.txt for an overview of the Vim source code. */ /* * Python extensions by Paul Moore, David Leonard, Roland Puntaier, Nikolay * Pavlov. * * Common code for if_python.c and if_python3.c. */ static char_u e_py_systemexit[] = "E880: Can't handle SystemExit of %s exception in vim"; #if PY_VERSION_HEX < 0x02050000 typedef int Py_ssize_t; // Python 2.4 and earlier don't have this type. #endif // Use values that are known to work, others may make Vim crash. #define ENC_OPT (enc_utf8 ? "utf-8" : enc_dbcs ? "euc-jp" : (char *)p_enc) #define DOPY_FUNC "_vim_pydo" static const char *vim_special_path = "_vim_path_"; #define PyErr_SET_STRING(exc, str) PyErr_SetString(exc, _(str)) #define PyErr_SetVim(str) PyErr_SetString(VimError, str) #define PyErr_SET_VIM(str) PyErr_SET_STRING(VimError, str) #define PyErr_FORMAT(exc, str, arg) PyErr_Format(exc, _(str), arg) #define PyErr_FORMAT2(exc, str, arg1, arg2) PyErr_Format(exc, _(str), arg1,arg2) #define PyErr_VIM_FORMAT(str, arg) PyErr_FORMAT(VimError, str, arg) #define Py_TYPE_NAME(obj) (obj->ob_type->tp_name == NULL \ ? "(NULL)" \ : obj->ob_type->tp_name) #define RAISE_NO_EMPTY_KEYS PyErr_SET_STRING(PyExc_ValueError, \ N_("empty keys are not allowed")) #define RAISE_LOCKED_DICTIONARY PyErr_SET_VIM(N_("dictionary is locked")) #define RAISE_LOCKED_LIST PyErr_SET_VIM(N_("list is locked")) #define RAISE_UNDO_FAIL PyErr_SET_VIM(N_("cannot save undo information")) #define RAISE_DELETE_LINE_FAIL PyErr_SET_VIM(N_("cannot delete line")) #define RAISE_INSERT_LINE_FAIL PyErr_SET_VIM(N_("cannot insert line")) #define RAISE_REPLACE_LINE_FAIL PyErr_SET_VIM(N_("cannot replace line")) #define RAISE_KEY_ADD_FAIL(key) \ PyErr_VIM_FORMAT(N_("failed to add key '%s' to dictionary"), key) #define RAISE_INVALID_INDEX_TYPE(idx) \ PyErr_FORMAT(PyExc_TypeError, N_("index must be int or slice, not %s"), \ Py_TYPE_NAME(idx)); #define INVALID_BUFFER_VALUE ((buf_T *)(-1)) #define INVALID_WINDOW_VALUE ((win_T *)(-1)) #define INVALID_TABPAGE_VALUE ((tabpage_T *)(-1)) typedef void (*rangeinitializer)(void *); typedef void (*runner)(const char *, void * #ifdef PY_CAN_RECURSE , PyGILState_STATE * #endif ); static int ConvertFromPyObject(PyObject *, typval_T *); static int _ConvertFromPyObject(PyObject *, typval_T *, PyObject *); static int ConvertFromPyMapping(PyObject *, typval_T *); static int ConvertFromPySequence(PyObject *, typval_T *); static PyObject *WindowNew(win_T *, tabpage_T *); static PyObject *BufferNew (buf_T *); static PyObject *LineToString(const char *); static PyInt RangeStart; static PyInt RangeEnd; static PyObject *globals; static PyObject *py_chdir; static PyObject *py_fchdir; static PyObject *py_getcwd; static PyObject *vim_module; static PyObject *vim_special_path_object; #if PY_VERSION_HEX >= 0x030700f0 static PyObject *py_find_spec; #else static PyObject *py_load_module; #endif static PyObject *py_find_module; static PyObject *VimError; /* * obtain a lock on the Vim data structures */ static void Python_Lock_Vim(void) { } /* * release a lock on the Vim data structures */ static void Python_Release_Vim(void) { } /* * The "todecref" argument holds a pointer to PyObject * that must be * DECREF'ed after returned char_u * is no longer needed or NULL if all what * was needed to generate returned value is object. * * Use Py_XDECREF to decrement reference count. */ static char_u * StringToChars(PyObject *obj, PyObject **todecref) { char_u *str; if (PyBytes_Check(obj)) { if (PyBytes_AsStringAndSize(obj, (char **) &str, NULL) == -1 || str == NULL) return NULL; *todecref = NULL; } else if (PyUnicode_Check(obj)) { PyObject *bytes; if (!(bytes = PyUnicode_AsEncodedString(obj, ENC_OPT, NULL))) return NULL; if(PyBytes_AsStringAndSize(bytes, (char **) &str, NULL) == -1 || str == NULL) { Py_DECREF(bytes); return NULL; } *todecref = bytes; } else { #if PY_MAJOR_VERSION < 3 PyErr_FORMAT(PyExc_TypeError, N_("expected str() or unicode() instance, but got %s"), Py_TYPE_NAME(obj)); #else PyErr_FORMAT(PyExc_TypeError, N_("expected bytes() or str() instance, but got %s"), Py_TYPE_NAME(obj)); #endif return NULL; } return (char_u *) str; } #define NUMBER_LONG 1 #define NUMBER_INT 2 #define NUMBER_NATURAL 4 #define NUMBER_UNSIGNED 8 static int NumberToLong(PyObject *obj, long *result, int flags) { #if PY_MAJOR_VERSION < 3 if (PyInt_Check(obj)) { *result = PyInt_AsLong(obj); if (PyErr_Occurred()) return -1; } else #endif if (PyLong_Check(obj)) { *result = PyLong_AsLong(obj); if (PyErr_Occurred()) return -1; } else if (PyNumber_Check(obj)) { PyObject *num; if (!(num = PyNumber_Long(obj))) return -1; *result = PyLong_AsLong(num); Py_DECREF(num); if (PyErr_Occurred()) return -1; } else { #if PY_MAJOR_VERSION < 3 PyErr_FORMAT(PyExc_TypeError, N_("expected int(), long() or something supporting " "coercing to long(), but got %s"), Py_TYPE_NAME(obj)); #else PyErr_FORMAT(PyExc_TypeError, N_("expected int() or something supporting coercing to int(), " "but got %s"), Py_TYPE_NAME(obj)); #endif return -1; } if (flags & NUMBER_INT) { if (*result > INT_MAX) { PyErr_SET_STRING(PyExc_OverflowError, N_("value is too large to fit into C int type")); return -1; } else if (*result < INT_MIN) { PyErr_SET_STRING(PyExc_OverflowError, N_("value is too small to fit into C int type")); return -1; } } if (flags & NUMBER_NATURAL) { if (*result <= 0) { PyErr_SET_STRING(PyExc_ValueError, N_("number must be greater than zero")); return -1; } } else if (flags & NUMBER_UNSIGNED) { if (*result < 0) { PyErr_SET_STRING(PyExc_ValueError, N_("number must be greater or equal to zero")); return -1; } } return 0; } static int add_string(PyObject *list, char *s) { PyObject *string; if (!(string = PyString_FromString(s))) return -1; if (PyList_Append(list, string)) { Py_DECREF(string); return -1; } Py_DECREF(string); return 0; } static PyObject * ObjectDir(PyObject *self, char **attributes) { PyMethodDef *method; char **attr; PyObject *ret; if (!(ret = PyList_New(0))) return NULL; if (self) for (method = self->ob_type->tp_methods ; method->ml_name != NULL ; ++method) if (add_string(ret, (char *)method->ml_name)) { Py_DECREF(ret); return NULL; } for (attr = attributes ; *attr ; ++attr) if (add_string(ret, *attr)) { Py_DECREF(ret); return NULL; } #if PY_MAJOR_VERSION < 3 if (add_string(ret, "__members__")) { Py_DECREF(ret); return NULL; } #endif return ret; } // Output buffer management // Function to write a line, points to either msg() or emsg(). typedef void (*writefn)(char_u *); static PyTypeObject OutputType; typedef struct { PyObject_HEAD long softspace; long error; } OutputObject; static char *OutputAttrs[] = { "softspace", NULL }; static PyObject * OutputDir(PyObject *self) { return ObjectDir(self, OutputAttrs); } static int OutputSetattr(OutputObject *self, char *name, PyObject *valObject) { if (valObject == NULL) { PyErr_SET_STRING(PyExc_AttributeError, N_("can't delete OutputObject attributes")); return -1; } if (strcmp(name, "softspace") == 0) { if (NumberToLong(valObject, &(self->softspace), NUMBER_UNSIGNED)) return -1; return 0; } PyErr_FORMAT(PyExc_AttributeError, N_("invalid attribute: %s"), name); return -1; } // Buffer IO, we write one whole line at a time. static garray_T io_ga = {0, 0, 1, 80, NULL}; static writefn old_fn = NULL; static void PythonIO_Flush(void) { if (old_fn != NULL && io_ga.ga_len > 0) { ((char_u *)io_ga.ga_data)[io_ga.ga_len] = NUL; old_fn((char_u *)io_ga.ga_data); } io_ga.ga_len = 0; } static void writer(writefn fn, char_u *str, PyInt n) { char_u *ptr; // Flush when switching output function. if (fn != old_fn) PythonIO_Flush(); old_fn = fn; // Write each NL separated line. Text after the last NL is kept for // writing later. // For normal messages: Do not output when "got_int" was set. This avoids // a loop gone crazy flooding the terminal with messages. Also for when // "q" is pressed at the more-prompt. while (n > 0 && (ptr = memchr(str, '\n', n)) != NULL && (fn == (writefn)emsg || !got_int)) { PyInt len = ptr - str; if (ga_grow(&io_ga, (int)(len + 1)) == FAIL) break; mch_memmove(((char *)io_ga.ga_data) + io_ga.ga_len, str, (size_t)len); ((char *)io_ga.ga_data)[io_ga.ga_len + len] = NUL; fn((char_u *)io_ga.ga_data); str = ptr + 1; n -= len + 1; io_ga.ga_len = 0; } // Put the remaining text into io_ga for later printing. if (n > 0 && (fn == (writefn)emsg || !got_int) && ga_grow(&io_ga, (int)(n + 1)) == OK) { mch_memmove(((char *)io_ga.ga_data) + io_ga.ga_len, str, (size_t)n); io_ga.ga_len += (int)n; } } static int write_output(OutputObject *self, PyObject *string) { Py_ssize_t len = 0; char *str = NULL; int error = self->error; if (!PyArg_Parse(string, "et#", ENC_OPT, &str, &len)) return -1; Py_BEGIN_ALLOW_THREADS Python_Lock_Vim(); if (error) emsg_severe = TRUE; writer((writefn)(error ? emsg : msg), (char_u *)str, len); Python_Release_Vim(); Py_END_ALLOW_THREADS PyMem_Free(str); return 0; } static PyObject * OutputWrite(OutputObject *self, PyObject *string) { if (write_output(self, string)) return NULL; Py_INCREF(Py_None); return Py_None; } static PyObject * OutputWritelines(OutputObject *self, PyObject *seq) { PyObject *iterator; PyObject *item; if (!(iterator = PyObject_GetIter(seq))) return NULL; while ((item = PyIter_Next(iterator))) { if (write_output(self, item)) { Py_DECREF(iterator); Py_DECREF(item); return NULL; } Py_DECREF(item); } Py_DECREF(iterator); // Iterator may have finished due to an exception if (PyErr_Occurred()) return NULL; Py_INCREF(Py_None); return Py_None; } static PyObject * AlwaysNone(PyObject *self UNUSED) { // do nothing Py_INCREF(Py_None); return Py_None; } static PyObject * AlwaysFalse(PyObject *self UNUSED) { // do nothing PyObject *ret = Py_False; Py_INCREF(ret); return ret; } static PyObject * AlwaysTrue(PyObject *self UNUSED) { // do nothing PyObject *ret = Py_True; Py_INCREF(ret); return ret; } /***************/ static struct PyMethodDef OutputMethods[] = { // name, function, calling, doc {"write", (PyCFunction)OutputWrite, METH_O, ""}, {"writelines", (PyCFunction)OutputWritelines, METH_O, ""}, {"flush", (PyCFunction)AlwaysNone, METH_NOARGS, ""}, {"close", (PyCFunction)AlwaysNone, METH_NOARGS, ""}, {"isatty", (PyCFunction)AlwaysFalse, METH_NOARGS, ""}, {"readable", (PyCFunction)AlwaysFalse, METH_NOARGS, ""}, {"seekable", (PyCFunction)AlwaysFalse, METH_NOARGS, ""}, {"writable", (PyCFunction)AlwaysTrue, METH_NOARGS, ""}, {"closed", (PyCFunction)AlwaysFalse, METH_NOARGS, ""}, {"__dir__", (PyCFunction)OutputDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; static OutputObject Output = { PyObject_HEAD_INIT(&OutputType) 0, 0 }; static OutputObject Error = { PyObject_HEAD_INIT(&OutputType) 0, 1 }; static int PythonIO_Init_io(void) { if (PySys_SetObject("stdout", (PyObject *)(void *)&Output)) return -1; if (PySys_SetObject("stderr", (PyObject *)(void *)&Error)) return -1; if (PyErr_Occurred()) { emsg(_("E264: Python: Error initialising I/O objects")); return -1; } return 0; } #if PY_VERSION_HEX < 0x030700f0 static PyObject *call_load_module(char *name, int len, PyObject *find_module_result); typedef struct { PyObject_HEAD char *fullname; PyObject *result; } LoaderObject; static PyTypeObject LoaderType; static void LoaderDestructor(LoaderObject *self) { vim_free(self->fullname); Py_XDECREF(self->result); DESTRUCTOR_FINISH(self); } static PyObject * LoaderLoadModule(LoaderObject *self, PyObject *args UNUSED) { char *fullname = self->fullname; PyObject *result = self->result; PyObject *module; if (!fullname) { module = result ? result : Py_None; Py_INCREF(module); return module; } module = call_load_module(fullname, (int)STRLEN(fullname), result); self->fullname = NULL; self->result = module; vim_free(fullname); Py_DECREF(result); if (!module) { if (PyErr_Occurred()) return NULL; Py_INCREF(Py_None); return Py_None; } Py_INCREF(module); return module; } static struct PyMethodDef LoaderMethods[] = { // name, function, calling, doc {"load_module", (PyCFunction)LoaderLoadModule, METH_VARARGS, ""}, { NULL, NULL, 0, NULL} }; #endif /* * Check to see whether a Vim error has been reported, or a keyboard * interrupt has been detected. */ static void VimTryStart(void) { ++trylevel; } static int VimTryEnd(void) { --trylevel; // Without this it stops processing all subsequent Vim script commands and // generates strange error messages if I e.g. try calling Test() in a cycle did_emsg = FALSE; // Keyboard interrupt should be preferred over anything else if (got_int) { if (did_throw) discard_current_exception(); got_int = FALSE; PyErr_SetNone(PyExc_KeyboardInterrupt); return -1; } else if (msg_list != NULL && *msg_list != NULL) { int should_free; char *msg; msg = get_exception_string(*msg_list, ET_ERROR, NULL, &should_free); if (msg == NULL) { PyErr_NoMemory(); return -1; } PyErr_SetVim(msg); free_global_msglist(); if (should_free) vim_free(msg); return -1; } else if (!did_throw) return (PyErr_Occurred() ? -1 : 0); // Python exception is preferred over vim one; unlikely to occur though else if (PyErr_Occurred()) { discard_current_exception(); return -1; } // Finally transform Vim script exception to python one else { PyErr_SetVim((char *)current_exception->value); discard_current_exception(); return -1; } } static int VimCheckInterrupt(void) { if (got_int) { PyErr_SetNone(PyExc_KeyboardInterrupt); return 1; } return 0; } // Vim module - Implementation static PyObject * VimCommand(PyObject *self UNUSED, PyObject *string) { char_u *cmd; PyObject *ret; PyObject *todecref; if (!(cmd = StringToChars(string, &todecref))) return NULL; Py_BEGIN_ALLOW_THREADS Python_Lock_Vim(); VimTryStart(); do_cmdline_cmd(cmd); update_screen(VALID); Python_Release_Vim(); Py_END_ALLOW_THREADS if (VimTryEnd()) ret = NULL; else ret = Py_None; Py_XINCREF(ret); Py_XDECREF(todecref); return ret; } /* * Function to translate a typval_T into a PyObject; this will recursively * translate lists/dictionaries into their Python equivalents. * * The depth parameter is to avoid infinite recursion, set it to 1 when * you call VimToPython. */ static PyObject * VimToPython(typval_T *our_tv, int depth, PyObject *lookup_dict) { PyObject *ret; PyObject *newObj; char ptrBuf[sizeof(void *) * 2 + 3]; // Avoid infinite recursion if (depth > 100) { Py_INCREF(Py_None); ret = Py_None; return ret; } // Check if we run into a recursive loop. The item must be in lookup_dict // then and we can use it again. if ((our_tv->v_type == VAR_LIST && our_tv->vval.v_list != NULL) || (our_tv->v_type == VAR_DICT && our_tv->vval.v_dict != NULL)) { sprintf(ptrBuf, "%p", our_tv->v_type == VAR_LIST ? (void *)our_tv->vval.v_list : (void *)our_tv->vval.v_dict); if ((ret = PyDict_GetItemString(lookup_dict, ptrBuf))) { Py_INCREF(ret); return ret; } } if (our_tv->v_type == VAR_STRING) ret = PyString_FromString(our_tv->vval.v_string == NULL ? "" : (char *)our_tv->vval.v_string); else if (our_tv->v_type == VAR_NUMBER) { char buf[NUMBUFLEN]; // For backwards compatibility numbers are stored as strings. sprintf(buf, "%ld", (long)our_tv->vval.v_number); ret = PyString_FromString((char *)buf); } #ifdef FEAT_FLOAT else if (our_tv->v_type == VAR_FLOAT) { char buf[NUMBUFLEN]; sprintf(buf, "%f", our_tv->vval.v_float); ret = PyString_FromString((char *)buf); } #endif else if (our_tv->v_type == VAR_LIST) { list_T *list = our_tv->vval.v_list; listitem_T *curr; if (list == NULL) return NULL; if (!(ret = PyList_New(0))) return NULL; if (PyDict_SetItemString(lookup_dict, ptrBuf, ret)) { Py_DECREF(ret); return NULL; } range_list_materialize(list); for (curr = list->lv_first; curr != NULL; curr = curr->li_next) { if (!(newObj = VimToPython(&curr->li_tv, depth + 1, lookup_dict))) { Py_DECREF(ret); return NULL; } if (PyList_Append(ret, newObj)) { Py_DECREF(newObj); Py_DECREF(ret); return NULL; } Py_DECREF(newObj); } } else if (our_tv->v_type == VAR_DICT) { hashtab_T *ht; long_u todo; hashitem_T *hi; dictitem_T *di; if (our_tv->vval.v_dict == NULL) return NULL; ht = &our_tv->vval.v_dict->dv_hashtab; if (!(ret = PyDict_New())) return NULL; if (PyDict_SetItemString(lookup_dict, ptrBuf, ret)) { Py_DECREF(ret); return NULL; } todo = ht->ht_used; for (hi = ht->ht_array; todo > 0; ++hi) { if (!HASHITEM_EMPTY(hi)) { --todo; di = dict_lookup(hi); if (!(newObj = VimToPython(&di->di_tv, depth + 1, lookup_dict))) { Py_DECREF(ret); return NULL; } if (PyDict_SetItemString(ret, (char *)hi->hi_key, newObj)) { Py_DECREF(ret); Py_DECREF(newObj); return NULL; } } } } else if (our_tv->v_type == VAR_BOOL) { if (our_tv->vval.v_number == VVAL_FALSE) { ret = Py_False; Py_INCREF(ret); } else { ret = Py_True; Py_INCREF(ret); } return ret; } else if (our_tv->v_type == VAR_SPECIAL) { Py_INCREF(Py_None); ret = Py_None; return ret; } else if (our_tv->v_type == VAR_BLOB) ret = PyBytes_FromStringAndSize( (char*) our_tv->vval.v_blob->bv_ga.ga_data, (Py_ssize_t) our_tv->vval.v_blob->bv_ga.ga_len); else { Py_INCREF(Py_None); ret = Py_None; } return ret; } static PyObject * VimEval(PyObject *self UNUSED, PyObject *args) { char_u *expr; typval_T *our_tv; PyObject *string; PyObject *todecref; PyObject *ret; PyObject *lookup_dict; if (!PyArg_ParseTuple(args, "O", &string)) return NULL; if (!(expr = StringToChars(string, &todecref))) return NULL; Py_BEGIN_ALLOW_THREADS Python_Lock_Vim(); VimTryStart(); our_tv = eval_expr(expr, NULL); Python_Release_Vim(); Py_END_ALLOW_THREADS Py_XDECREF(todecref); if (VimTryEnd()) return NULL; if (our_tv == NULL) { PyErr_SET_VIM(N_("invalid expression")); return NULL; } // Convert the Vim type into a Python type. Create a dictionary that's // used to check for recursive loops. if (!(lookup_dict = PyDict_New())) ret = NULL; else { ret = VimToPython(our_tv, 1, lookup_dict); Py_DECREF(lookup_dict); } Py_BEGIN_ALLOW_THREADS Python_Lock_Vim(); free_tv(our_tv); Python_Release_Vim(); Py_END_ALLOW_THREADS return ret; } static PyObject *ConvertToPyObject(typval_T *); static PyObject * VimEvalPy(PyObject *self UNUSED, PyObject *string) { typval_T *our_tv; PyObject *ret; char_u *expr; PyObject *todecref; if (!(expr = StringToChars(string, &todecref))) return NULL; Py_BEGIN_ALLOW_THREADS Python_Lock_Vim(); VimTryStart(); our_tv = eval_expr(expr, NULL); Python_Release_Vim(); Py_END_ALLOW_THREADS Py_XDECREF(todecref); if (VimTryEnd()) return NULL; if (our_tv == NULL) { PyErr_SET_VIM(N_("invalid expression")); return NULL; } ret = ConvertToPyObject(our_tv); Py_BEGIN_ALLOW_THREADS Python_Lock_Vim(); free_tv(our_tv); Python_Release_Vim(); Py_END_ALLOW_THREADS return ret; } static PyObject * VimStrwidth(PyObject *self UNUSED, PyObject *string) { char_u *str; PyObject *todecref; int len; if (!(str = StringToChars(string, &todecref))) return NULL; len = mb_string2cells(str, (int)STRLEN(str)); Py_XDECREF(todecref); return PyLong_FromLong(len); } static PyObject * _VimChdir(PyObject *_chdir, PyObject *args, PyObject *kwargs) { PyObject *ret; PyObject *newwd; PyObject *todecref; char_u *new_dir; if (_chdir == NULL) return NULL; if (!(ret = PyObject_Call(_chdir, args, kwargs))) return NULL; if (!(newwd = PyObject_CallFunctionObjArgs(py_getcwd, NULL))) { Py_DECREF(ret); return NULL; } if (!(new_dir = StringToChars(newwd, &todecref))) { Py_DECREF(ret); Py_DECREF(newwd); return NULL; } VimTryStart(); if (vim_chdir(new_dir)) { Py_DECREF(ret); Py_DECREF(newwd); Py_XDECREF(todecref); if (VimTryEnd()) return NULL; PyErr_SET_VIM(N_("failed to change directory")); return NULL; } Py_DECREF(newwd); Py_XDECREF(todecref); post_chdir(CDSCOPE_GLOBAL); if (VimTryEnd()) { Py_DECREF(ret); return NULL; } return ret; } static PyObject * VimChdir(PyObject *self UNUSED, PyObject *args, PyObject *kwargs) { return _VimChdir(py_chdir, args, kwargs); } static PyObject * VimFchdir(PyObject *self UNUSED, PyObject *args, PyObject *kwargs) { return _VimChdir(py_fchdir, args, kwargs); } typedef struct { PyObject *callable; PyObject *result; } map_rtp_data; static void map_rtp_callback(char_u *path, void *_data) { void **data = (void **) _data; PyObject *pathObject; map_rtp_data *mr_data = *((map_rtp_data **) data); if (!(pathObject = PyString_FromString((char *)path))) { *data = NULL; return; } mr_data->result = PyObject_CallFunctionObjArgs(mr_data->callable, pathObject, NULL); Py_DECREF(pathObject); if (!mr_data->result || mr_data->result != Py_None) *data = NULL; else { Py_DECREF(mr_data->result); mr_data->result = NULL; } } static PyObject * VimForeachRTP(PyObject *self UNUSED, PyObject *callable) { map_rtp_data data; data.callable = callable; data.result = NULL; do_in_runtimepath(NULL, 0, &map_rtp_callback, &data); if (data.result == NULL) { if (PyErr_Occurred()) return NULL; else { Py_INCREF(Py_None); return Py_None; } } return data.result; } /* * _vim_runtimepath_ special path implementation. */ static void map_finder_callback(char_u *path, void *_data) { void **data = (void **) _data; PyObject *list = *((PyObject **) data); PyObject *pathObject1, *pathObject2; char *pathbuf; size_t pathlen; pathlen = STRLEN(path); #if PY_MAJOR_VERSION < 3 # define PY_MAIN_DIR_STRING "python2" #else # define PY_MAIN_DIR_STRING "python3" #endif #define PY_ALTERNATE_DIR_STRING "pythonx" #define PYTHONX_STRING_LENGTH 7 // STRLEN("pythonx") if (!(pathbuf = PyMem_New(char, pathlen + STRLEN(PATHSEPSTR) + PYTHONX_STRING_LENGTH + 1))) { PyErr_NoMemory(); *data = NULL; return; } mch_memmove(pathbuf, path, pathlen + 1); add_pathsep((char_u *) pathbuf); pathlen = STRLEN(pathbuf); mch_memmove(pathbuf + pathlen, PY_MAIN_DIR_STRING, PYTHONX_STRING_LENGTH + 1); if (!(pathObject1 = PyString_FromString(pathbuf))) { *data = NULL; PyMem_Free(pathbuf); return; } mch_memmove(pathbuf + pathlen, PY_ALTERNATE_DIR_STRING, PYTHONX_STRING_LENGTH + 1); if (!(pathObject2 = PyString_FromString(pathbuf))) { Py_DECREF(pathObject1); PyMem_Free(pathbuf); *data = NULL; return; } PyMem_Free(pathbuf); if (PyList_Append(list, pathObject1) || PyList_Append(list, pathObject2)) *data = NULL; Py_DECREF(pathObject1); Py_DECREF(pathObject2); } static PyObject * Vim_GetPaths(PyObject *self UNUSED) { PyObject *ret; if (!(ret = PyList_New(0))) return NULL; do_in_runtimepath(NULL, 0, &map_finder_callback, ret); if (PyErr_Occurred()) { Py_DECREF(ret); return NULL; } return ret; } #if PY_VERSION_HEX >= 0x030700f0 static PyObject * FinderFindSpec(PyObject *self, PyObject *args) { char *fullname; PyObject *paths; PyObject *target = Py_None; PyObject *spec; if (!PyArg_ParseTuple(args, "s|O", &fullname, &target)) return NULL; if (!(paths = Vim_GetPaths(self))) return NULL; spec = PyObject_CallFunction(py_find_spec, "sOO", fullname, paths, target); Py_DECREF(paths); if (!spec) { if (PyErr_Occurred()) return NULL; Py_INCREF(Py_None); return Py_None; } return spec; } static PyObject * FinderFindModule(PyObject* self UNUSED, PyObject* args UNUSED) { // Apparently returning None works. Py_INCREF(Py_None); return Py_None; } #else static PyObject * call_load_module(char *name, int len, PyObject *find_module_result) { PyObject *fd, *pathname, *description; if (!PyTuple_Check(find_module_result)) { PyErr_FORMAT(PyExc_TypeError, N_("expected 3-tuple as imp.find_module() result, but got %s"), Py_TYPE_NAME(find_module_result)); return NULL; } if (PyTuple_GET_SIZE(find_module_result) != 3) { PyErr_FORMAT(PyExc_TypeError, N_("expected 3-tuple as imp.find_module() result, but got " "tuple of size %d"), (int) PyTuple_GET_SIZE(find_module_result)); return NULL; } if (!(fd = PyTuple_GET_ITEM(find_module_result, 0)) || !(pathname = PyTuple_GET_ITEM(find_module_result, 1)) || !(description = PyTuple_GET_ITEM(find_module_result, 2))) { PyErr_SET_STRING(PyExc_RuntimeError, N_("internal error: imp.find_module returned tuple with NULL")); return NULL; } return PyObject_CallFunction(py_load_module, "s#OOO", name, len, fd, pathname, description); } static PyObject * find_module(char *fullname, char *tail, PyObject *new_path) { PyObject *find_module_result; PyObject *module; char *dot; if ((dot = (char *)vim_strchr((char_u *) tail, '.'))) { /* * There is a dot in the name: call find_module recursively without the * first component */ PyObject *newest_path; int partlen = (int) (dot - 1 - tail); if (!(find_module_result = PyObject_CallFunction(py_find_module, "s#O", tail, partlen, new_path))) { if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_ImportError)) PyErr_Clear(); return NULL; } if (!(module = call_load_module( fullname, ((int) (tail - fullname)) + partlen, find_module_result))) { Py_DECREF(find_module_result); return NULL; } Py_DECREF(find_module_result); if (!(newest_path = PyObject_GetAttrString(module, "__path__"))) { Py_DECREF(module); return NULL; } Py_DECREF(module); find_module_result = find_module(fullname, dot + 1, newest_path); Py_DECREF(newest_path); return find_module_result; } else { if (!(find_module_result = PyObject_CallFunction(py_find_module, "sO", tail, new_path))) { if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_ImportError)) PyErr_Clear(); return NULL; } return find_module_result; } } static PyObject * FinderFindModule(PyObject *self, PyObject *args) { char *fullname; PyObject *result; PyObject *new_path; LoaderObject *loader; if (!PyArg_ParseTuple(args, "s", &fullname)) return NULL; if (!(new_path = Vim_GetPaths(self))) return NULL; result = find_module(fullname, fullname, new_path); Py_DECREF(new_path); if (!result) { if (PyErr_Occurred()) return NULL; Py_INCREF(Py_None); return Py_None; } if (!(fullname = (char *)vim_strsave((char_u *)fullname))) { Py_DECREF(result); PyErr_NoMemory(); return NULL; } if (!(loader = PyObject_NEW(LoaderObject, &LoaderType))) { vim_free(fullname); Py_DECREF(result); return NULL; } loader->fullname = fullname; loader->result = result; return (PyObject *) loader; } #endif static PyObject * VimPathHook(PyObject *self UNUSED, PyObject *args) { char *path; if (PyArg_ParseTuple(args, "s", &path) && STRCMP(path, vim_special_path) == 0) { Py_INCREF(vim_module); return vim_module; } PyErr_Clear(); PyErr_SetNone(PyExc_ImportError); return NULL; } /* * Vim module - Definitions */ static struct PyMethodDef VimMethods[] = { // name, function, calling, documentation {"command", VimCommand, METH_O, "Execute a Vim ex-mode command" }, {"eval", VimEval, METH_VARARGS, "Evaluate an expression using Vim evaluator" }, {"bindeval", VimEvalPy, METH_O, "Like eval(), but returns objects attached to vim ones"}, {"strwidth", VimStrwidth, METH_O, "Screen string width, counts <Tab> as having width 1"}, {"chdir", (PyCFunction)VimChdir, METH_VARARGS|METH_KEYWORDS, "Change directory"}, {"fchdir", (PyCFunction)VimFchdir, METH_VARARGS|METH_KEYWORDS, "Change directory"}, {"foreach_rtp", VimForeachRTP, METH_O, "Call given callable for each path in &rtp"}, #if PY_VERSION_HEX >= 0x030700f0 {"find_spec", FinderFindSpec, METH_VARARGS, "Internal use only, returns spec object for any input it receives"}, #endif {"find_module", FinderFindModule, METH_VARARGS, "Internal use only, returns loader object for any input it receives"}, {"path_hook", VimPathHook, METH_VARARGS, "Hook function to install in sys.path_hooks"}, {"_get_paths", (PyCFunction)Vim_GetPaths, METH_NOARGS, "Get &rtp-based additions to sys.path"}, { NULL, NULL, 0, NULL} }; /* * Generic iterator object */ static PyTypeObject IterType; typedef PyObject *(*nextfun)(void **); typedef void (*destructorfun)(void *); typedef int (*traversefun)(void *, visitproc, void *); typedef int (*clearfun)(void **); // Main purpose of this object is removing the need for do python // initialization (i.e. PyType_Ready and setting type attributes) for a big // bunch of objects. typedef struct { PyObject_HEAD void *cur; nextfun next; destructorfun destruct; traversefun traverse; clearfun clear; } IterObject; static PyObject * IterNew(void *start, destructorfun destruct, nextfun next, traversefun traverse, clearfun clear) { IterObject *self; self = PyObject_GC_New(IterObject, &IterType); self->cur = start; self->next = next; self->destruct = destruct; self->traverse = traverse; self->clear = clear; return (PyObject *)(self); } static void IterDestructor(IterObject *self) { PyObject_GC_UnTrack((void *)(self)); self->destruct(self->cur); PyObject_GC_Del((void *)(self)); } static int IterTraverse(IterObject *self, visitproc visit, void *arg) { if (self->traverse != NULL) return self->traverse(self->cur, visit, arg); else return 0; } // Mac OSX defines clear() somewhere. #ifdef clear # undef clear #endif static int IterClear(IterObject *self) { if (self->clear != NULL) return self->clear(&self->cur); else return 0; } static PyObject * IterNext(IterObject *self) { return self->next(&self->cur); } static PyObject * IterIter(PyObject *self) { Py_INCREF(self); return self; } typedef struct pylinkedlist_S { struct pylinkedlist_S *pll_next; struct pylinkedlist_S *pll_prev; PyObject *pll_obj; } pylinkedlist_T; static pylinkedlist_T *lastdict = NULL; static pylinkedlist_T *lastlist = NULL; static pylinkedlist_T *lastfunc = NULL; static void pyll_remove(pylinkedlist_T *ref, pylinkedlist_T **last) { if (ref->pll_prev == NULL) { if (ref->pll_next == NULL) { *last = NULL; return; } } else ref->pll_prev->pll_next = ref->pll_next; if (ref->pll_next == NULL) *last = ref->pll_prev; else ref->pll_next->pll_prev = ref->pll_prev; } static void pyll_add(PyObject *self, pylinkedlist_T *ref, pylinkedlist_T **last) { if (*last == NULL) ref->pll_prev = NULL; else { (*last)->pll_next = ref; ref->pll_prev = *last; } ref->pll_next = NULL; ref->pll_obj = self; *last = ref; } static PyTypeObject DictionaryType; typedef struct { PyObject_HEAD dict_T *dict; pylinkedlist_T ref; } DictionaryObject; static PyObject *DictionaryUpdate(DictionaryObject *, PyObject *, PyObject *); #define NEW_DICTIONARY(dict) DictionaryNew(&DictionaryType, dict) static PyObject * DictionaryNew(PyTypeObject *subtype, dict_T *dict) { DictionaryObject *self; self = (DictionaryObject *) subtype->tp_alloc(subtype, 0); if (self == NULL) return NULL; self->dict = dict; ++dict->dv_refcount; pyll_add((PyObject *)(self), &self->ref, &lastdict); return (PyObject *)(self); } static dict_T * py_dict_alloc(void) { dict_T *ret; if (!(ret = dict_alloc())) { PyErr_NoMemory(); return NULL; } ++ret->dv_refcount; return ret; } static PyObject * DictionaryConstructor(PyTypeObject *subtype, PyObject *args, PyObject *kwargs) { DictionaryObject *self; dict_T *dict; if (!(dict = py_dict_alloc())) return NULL; self = (DictionaryObject *) DictionaryNew(subtype, dict); --dict->dv_refcount; if (kwargs || PyTuple_Size(args)) { PyObject *tmp; if (!(tmp = DictionaryUpdate(self, args, kwargs))) { Py_DECREF(self); return NULL; } Py_DECREF(tmp); } return (PyObject *)(self); } static void DictionaryDestructor(DictionaryObject *self) { pyll_remove(&self->ref, &lastdict); dict_unref(self->dict); DESTRUCTOR_FINISH(self); } static char *DictionaryAttrs[] = { "locked", "scope", NULL }; static PyObject * DictionaryDir(PyObject *self) { return ObjectDir(self, DictionaryAttrs); } static int DictionarySetattr(DictionaryObject *self, char *name, PyObject *valObject) { if (valObject == NULL) { PyErr_SET_STRING(PyExc_AttributeError, N_("cannot delete vim.Dictionary attributes")); return -1; } if (strcmp(name, "locked") == 0) { if (self->dict->dv_lock == VAR_FIXED) { PyErr_SET_STRING(PyExc_TypeError, N_("cannot modify fixed dictionary")); return -1; } else { int istrue = PyObject_IsTrue(valObject); if (istrue == -1) return -1; else if (istrue) self->dict->dv_lock = VAR_LOCKED; else self->dict->dv_lock = 0; } return 0; } else { PyErr_FORMAT(PyExc_AttributeError, N_("cannot set attribute %s"), name); return -1; } } static PyInt DictionaryLength(DictionaryObject *self) { return ((PyInt) (self->dict->dv_hashtab.ht_used)); } #define DICT_FLAG_HAS_DEFAULT 0x01 #define DICT_FLAG_POP 0x02 #define DICT_FLAG_NONE_DEFAULT 0x04 #define DICT_FLAG_RETURN_BOOL 0x08 // Incompatible with DICT_FLAG_POP #define DICT_FLAG_RETURN_PAIR 0x10 static PyObject * _DictionaryItem(DictionaryObject *self, PyObject *args, int flags) { PyObject *keyObject; PyObject *defObject = ((flags & DICT_FLAG_NONE_DEFAULT)? Py_None : NULL); PyObject *ret; char_u *key; dictitem_T *di; dict_T *dict = self->dict; hashitem_T *hi; PyObject *todecref; if (flags & DICT_FLAG_HAS_DEFAULT) { if (!PyArg_ParseTuple(args, "O|O", &keyObject, &defObject)) return NULL; } else keyObject = args; if (flags & DICT_FLAG_RETURN_BOOL) defObject = Py_False; if (!(key = StringToChars(keyObject, &todecref))) return NULL; if (*key == NUL) { RAISE_NO_EMPTY_KEYS; Py_XDECREF(todecref); return NULL; } hi = hash_find(&dict->dv_hashtab, key); Py_XDECREF(todecref); if (HASHITEM_EMPTY(hi)) { if (defObject) { Py_INCREF(defObject); return defObject; } else { PyErr_SetObject(PyExc_KeyError, keyObject); return NULL; } } else if (flags & DICT_FLAG_RETURN_BOOL) { ret = Py_True; Py_INCREF(ret); return ret; } di = dict_lookup(hi); if (!(ret = ConvertToPyObject(&di->di_tv))) return NULL; if (flags & DICT_FLAG_POP) { if (dict->dv_lock) { RAISE_LOCKED_DICTIONARY; Py_DECREF(ret); return NULL; } hash_remove(&dict->dv_hashtab, hi); dictitem_free(di); } return ret; } static PyObject * DictionaryItem(DictionaryObject *self, PyObject *keyObject) { return _DictionaryItem(self, keyObject, 0); } static int DictionaryContains(DictionaryObject *self, PyObject *keyObject) { PyObject *rObj = _DictionaryItem(self, keyObject, DICT_FLAG_RETURN_BOOL); int ret; if (rObj == NULL) return -1; ret = (rObj == Py_True); Py_DECREF(rObj); return ret; } typedef struct { hashitem_T *ht_array; long_u ht_used; hashtab_T *ht; hashitem_T *hi; long_u todo; } dictiterinfo_T; static PyObject * DictionaryIterNext(dictiterinfo_T **dii) { PyObject *ret; if (!(*dii)->todo) return NULL; if ((*dii)->ht->ht_array != (*dii)->ht_array || (*dii)->ht->ht_used != (*dii)->ht_used) { PyErr_SET_STRING(PyExc_RuntimeError, N_("hashtab changed during iteration")); return NULL; } while (((*dii)->todo) && HASHITEM_EMPTY((*dii)->hi)) ++((*dii)->hi); --((*dii)->todo); if (!(ret = PyBytes_FromString((char *)(*dii)->hi->hi_key))) return NULL; return ret; } static PyObject * DictionaryIter(DictionaryObject *self) { dictiterinfo_T *dii; hashtab_T *ht; if (!(dii = PyMem_New(dictiterinfo_T, 1))) { PyErr_NoMemory(); return NULL; } ht = &self->dict->dv_hashtab; dii->ht_array = ht->ht_array; dii->ht_used = ht->ht_used; dii->ht = ht; dii->hi = dii->ht_array; dii->todo = dii->ht_used; return IterNew(dii, (destructorfun) PyMem_Free, (nextfun) DictionaryIterNext, NULL, NULL); } static PyInt DictionaryAssItem( DictionaryObject *self, PyObject *keyObject, PyObject *valObject) { char_u *key; typval_T tv; dict_T *dict = self->dict; dictitem_T *di; PyObject *todecref; if (dict->dv_lock) { RAISE_LOCKED_DICTIONARY; return -1; } if (!(key = StringToChars(keyObject, &todecref))) return -1; if (*key == NUL) { RAISE_NO_EMPTY_KEYS; Py_XDECREF(todecref); return -1; } di = dict_find(dict, key, -1); if (valObject == NULL) { hashitem_T *hi; if (di == NULL) { Py_XDECREF(todecref); PyErr_SetObject(PyExc_KeyError, keyObject); return -1; } hi = hash_find(&dict->dv_hashtab, di->di_key); hash_remove(&dict->dv_hashtab, hi); dictitem_free(di); Py_XDECREF(todecref); return 0; } if (ConvertFromPyObject(valObject, &tv) == -1) { Py_XDECREF(todecref); return -1; } if (di == NULL) { if (!(di = dictitem_alloc(key))) { Py_XDECREF(todecref); PyErr_NoMemory(); return -1; } di->di_tv.v_type = VAR_UNKNOWN; if (dict_add(dict, di) == FAIL) { vim_free(di); dictitem_free(di); RAISE_KEY_ADD_FAIL(key); Py_XDECREF(todecref); return -1; } } else clear_tv(&di->di_tv); Py_XDECREF(todecref); copy_tv(&tv, &di->di_tv); clear_tv(&tv); return 0; } typedef PyObject *(*hi_to_py)(hashitem_T *); static PyObject * DictionaryListObjects(DictionaryObject *self, hi_to_py hiconvert) { dict_T *dict = self->dict; long_u todo = dict->dv_hashtab.ht_used; Py_ssize_t i = 0; PyObject *ret; hashitem_T *hi; PyObject *newObj; ret = PyList_New(todo); for (hi = dict->dv_hashtab.ht_array; todo > 0; ++hi) { if (!HASHITEM_EMPTY(hi)) { if (!(newObj = hiconvert(hi))) { Py_DECREF(ret); return NULL; } PyList_SET_ITEM(ret, i, newObj); --todo; ++i; } } return ret; } static PyObject * dict_key(hashitem_T *hi) { return PyBytes_FromString((char *)(hi->hi_key)); } static PyObject * DictionaryListKeys(DictionaryObject *self) { return DictionaryListObjects(self, dict_key); } static PyObject * dict_val(hashitem_T *hi) { dictitem_T *di; di = dict_lookup(hi); return ConvertToPyObject(&di->di_tv); } static PyObject * DictionaryListValues(DictionaryObject *self) { return DictionaryListObjects(self, dict_val); } static PyObject * dict_item(hashitem_T *hi) { PyObject *keyObject; PyObject *valObject; PyObject *ret; if (!(keyObject = dict_key(hi))) return NULL; if (!(valObject = dict_val(hi))) { Py_DECREF(keyObject); return NULL; } ret = Py_BuildValue("(OO)", keyObject, valObject); Py_DECREF(keyObject); Py_DECREF(valObject); return ret; } static PyObject * DictionaryListItems(DictionaryObject *self) { return DictionaryListObjects(self, dict_item); } static PyObject * DictionaryUpdate(DictionaryObject *self, PyObject *args, PyObject *kwargs) { dict_T *dict = self->dict; if (dict->dv_lock) { RAISE_LOCKED_DICTIONARY; return NULL; } if (kwargs) { typval_T tv; if (ConvertFromPyMapping(kwargs, &tv) == -1) return NULL; VimTryStart(); dict_extend(self->dict, tv.vval.v_dict, (char_u *) "force"); clear_tv(&tv); if (VimTryEnd()) return NULL; } else { PyObject *obj = NULL; if (!PyArg_ParseTuple(args, "|O", &obj)) return NULL; if (obj == NULL) { Py_INCREF(Py_None); return Py_None; } if (PyObject_HasAttrString(obj, "keys")) return DictionaryUpdate(self, NULL, obj); else { PyObject *iterator; PyObject *item; if (!(iterator = PyObject_GetIter(obj))) return NULL; while ((item = PyIter_Next(iterator))) { PyObject *fast; PyObject *keyObject; PyObject *valObject; PyObject *todecref; char_u *key; dictitem_T *di; hashitem_T *hi; if (!(fast = PySequence_Fast(item, ""))) { Py_DECREF(iterator); Py_DECREF(item); return NULL; } Py_DECREF(item); if (PySequence_Fast_GET_SIZE(fast) != 2) { Py_DECREF(iterator); Py_DECREF(fast); PyErr_FORMAT(PyExc_ValueError, N_("expected sequence element of size 2, " "but got sequence of size %d"), (int) PySequence_Fast_GET_SIZE(fast)); return NULL; } keyObject = PySequence_Fast_GET_ITEM(fast, 0); if (!(key = StringToChars(keyObject, &todecref))) { Py_DECREF(iterator); Py_DECREF(fast); return NULL; } di = dictitem_alloc(key); Py_XDECREF(todecref); if (di == NULL) { Py_DECREF(fast); Py_DECREF(iterator); PyErr_NoMemory(); return NULL; } di->di_tv.v_type = VAR_UNKNOWN; valObject = PySequence_Fast_GET_ITEM(fast, 1); if (ConvertFromPyObject(valObject, &di->di_tv) == -1) { Py_DECREF(iterator); Py_DECREF(fast); dictitem_free(di); return NULL; } Py_DECREF(fast); hi = hash_find(&dict->dv_hashtab, di->di_key); if (!HASHITEM_EMPTY(hi) || dict_add(dict, di) == FAIL) { RAISE_KEY_ADD_FAIL(di->di_key); Py_DECREF(iterator); dictitem_free(di); return NULL; } } Py_DECREF(iterator); // Iterator may have finished due to an exception if (PyErr_Occurred()) return NULL; } } Py_INCREF(Py_None); return Py_None; } static PyObject * DictionaryGet(DictionaryObject *self, PyObject *args) { return _DictionaryItem(self, args, DICT_FLAG_HAS_DEFAULT|DICT_FLAG_NONE_DEFAULT); } static PyObject * DictionaryPop(DictionaryObject *self, PyObject *args) { return _DictionaryItem(self, args, DICT_FLAG_HAS_DEFAULT|DICT_FLAG_POP); } static PyObject * DictionaryPopItem(DictionaryObject *self) { hashitem_T *hi; PyObject *ret; PyObject *valObject; dictitem_T *di; if (self->dict->dv_hashtab.ht_used == 0) { PyErr_SetNone(PyExc_KeyError); return NULL; } hi = self->dict->dv_hashtab.ht_array; while (HASHITEM_EMPTY(hi)) ++hi; di = dict_lookup(hi); if (!(valObject = ConvertToPyObject(&di->di_tv))) return NULL; if (!(ret = Py_BuildValue("(" Py_bytes_fmt "O)", hi->hi_key, valObject))) { Py_DECREF(valObject); return NULL; } hash_remove(&self->dict->dv_hashtab, hi); dictitem_free(di); return ret; } static PyObject * DictionaryHasKey(DictionaryObject *self, PyObject *keyObject) { return _DictionaryItem(self, keyObject, DICT_FLAG_RETURN_BOOL); } static PySequenceMethods DictionaryAsSeq = { 0, // sq_length 0, // sq_concat 0, // sq_repeat 0, // sq_item 0, // sq_slice 0, // sq_ass_item 0, // sq_ass_slice (objobjproc) DictionaryContains, // sq_contains 0, // sq_inplace_concat 0, // sq_inplace_repeat }; static PyMappingMethods DictionaryAsMapping = { (lenfunc) DictionaryLength, (binaryfunc) DictionaryItem, (objobjargproc) DictionaryAssItem, }; static struct PyMethodDef DictionaryMethods[] = { {"keys", (PyCFunction)DictionaryListKeys, METH_NOARGS, ""}, {"values", (PyCFunction)DictionaryListValues, METH_NOARGS, ""}, {"items", (PyCFunction)DictionaryListItems, METH_NOARGS, ""}, {"update", (PyCFunction)DictionaryUpdate, METH_VARARGS|METH_KEYWORDS, ""}, {"get", (PyCFunction)DictionaryGet, METH_VARARGS, ""}, {"pop", (PyCFunction)DictionaryPop, METH_VARARGS, ""}, {"popitem", (PyCFunction)DictionaryPopItem, METH_NOARGS, ""}, {"has_key", (PyCFunction)DictionaryHasKey, METH_O, ""}, {"__dir__", (PyCFunction)DictionaryDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; static PyTypeObject ListType; typedef struct { PyObject_HEAD list_T *list; pylinkedlist_T ref; } ListObject; #define NEW_LIST(list) ListNew(&ListType, list) static PyObject * ListNew(PyTypeObject *subtype, list_T *list) { ListObject *self; self = (ListObject *) subtype->tp_alloc(subtype, 0); if (self == NULL) return NULL; self->list = list; ++list->lv_refcount; range_list_materialize(list); pyll_add((PyObject *)(self), &self->ref, &lastlist); return (PyObject *)(self); } static list_T * py_list_alloc(void) { list_T *ret; if (!(ret = list_alloc())) { PyErr_NoMemory(); return NULL; } ++ret->lv_refcount; return ret; } static int list_py_concat(list_T *l, PyObject *obj, PyObject *lookup_dict) { PyObject *iterator; PyObject *item; listitem_T *li; if (!(iterator = PyObject_GetIter(obj))) return -1; while ((item = PyIter_Next(iterator))) { if (!(li = listitem_alloc())) { PyErr_NoMemory(); Py_DECREF(item); Py_DECREF(iterator); return -1; } li->li_tv.v_lock = 0; li->li_tv.v_type = VAR_UNKNOWN; if (_ConvertFromPyObject(item, &li->li_tv, lookup_dict) == -1) { Py_DECREF(item); Py_DECREF(iterator); listitem_free(l, li); return -1; } Py_DECREF(item); list_append(l, li); } Py_DECREF(iterator); // Iterator may have finished due to an exception if (PyErr_Occurred()) return -1; return 0; } static PyObject * ListConstructor(PyTypeObject *subtype, PyObject *args, PyObject *kwargs) { list_T *list; PyObject *obj = NULL; if (kwargs) { PyErr_SET_STRING(PyExc_TypeError, N_("list constructor does not accept keyword arguments")); return NULL; } if (!PyArg_ParseTuple(args, "|O", &obj)) return NULL; if (!(list = py_list_alloc())) return NULL; if (obj) { PyObject *lookup_dict; if (!(lookup_dict = PyDict_New())) { list_unref(list); return NULL; } if (list_py_concat(list, obj, lookup_dict) == -1) { Py_DECREF(lookup_dict); list_unref(list); return NULL; } Py_DECREF(lookup_dict); } return ListNew(subtype, list); } static void ListDestructor(ListObject *self) { pyll_remove(&self->ref, &lastlist); list_unref(self->list); DESTRUCTOR_FINISH(self); } static PyInt ListLength(ListObject *self) { return ((PyInt) (self->list->lv_len)); } static PyObject * ListIndex(ListObject *self, Py_ssize_t index) { listitem_T *li; if (index >= ListLength(self)) { PyErr_SET_STRING(PyExc_IndexError, N_("list index out of range")); return NULL; } li = list_find(self->list, (long) index); if (li == NULL) { // No more suitable format specifications in python-2.3 PyErr_VIM_FORMAT(N_("internal error: failed to get vim list item %d"), (int) index); return NULL; } return ConvertToPyObject(&li->li_tv); } static PyObject * ListSlice(ListObject *self, Py_ssize_t first, Py_ssize_t step, Py_ssize_t slicelen) { PyInt i; PyObject *list; if (step == 0) { PyErr_SET_STRING(PyExc_ValueError, N_("slice step cannot be zero")); return NULL; } list = PyList_New(slicelen); if (list == NULL) return NULL; for (i = 0; i < slicelen; ++i) { PyObject *item; item = ListIndex(self, first + i*step); if (item == NULL) { Py_DECREF(list); return NULL; } PyList_SET_ITEM(list, i, item); } return list; } static PyObject * ListItem(ListObject *self, PyObject* idx) { #if PY_MAJOR_VERSION < 3 if (PyInt_Check(idx)) { long _idx = PyInt_AsLong(idx); return ListIndex(self, _idx); } else #endif if (PyLong_Check(idx)) { long _idx = PyLong_AsLong(idx); return ListIndex(self, _idx); } else if (PySlice_Check(idx)) { Py_ssize_t start, stop, step, slicelen; if (PySlice_GetIndicesEx((PySliceObject_T *)idx, ListLength(self), &start, &stop, &step, &slicelen) < 0) return NULL; return ListSlice(self, start, step, slicelen); } else { RAISE_INVALID_INDEX_TYPE(idx); return NULL; } } static void list_restore(Py_ssize_t numadded, Py_ssize_t numreplaced, Py_ssize_t slicelen, list_T *l, listitem_T **lis, listitem_T *lastaddedli) { while (numreplaced--) { list_insert(l, lis[numreplaced], lis[slicelen + numreplaced]); listitem_remove(l, lis[slicelen + numreplaced]); } while (numadded--) { listitem_T *next; next = lastaddedli->li_prev; listitem_remove(l, lastaddedli); lastaddedli = next; } } static int ListAssSlice(ListObject *self, Py_ssize_t first, Py_ssize_t step, Py_ssize_t slicelen, PyObject *obj) { PyObject *iterator; PyObject *item; listitem_T *li; listitem_T *lastaddedli = NULL; listitem_T *next; typval_T v; list_T *l = self->list; PyInt i; PyInt j; PyInt numreplaced = 0; PyInt numadded = 0; PyInt size; listitem_T **lis = NULL; size = ListLength(self); if (l->lv_lock) { RAISE_LOCKED_LIST; return -1; } if (step == 0) { PyErr_SET_STRING(PyExc_ValueError, N_("slice step cannot be zero")); return -1; } if (step != 1 && slicelen == 0) { // Nothing to do. Only error out if obj has some items. int ret = 0; if (obj == NULL) return 0; if (!(iterator = PyObject_GetIter(obj))) return -1; if ((item = PyIter_Next(iterator))) { PyErr_FORMAT(PyExc_ValueError, N_("attempt to assign sequence of size greater than %d " "to extended slice"), 0); Py_DECREF(item); ret = -1; } Py_DECREF(iterator); return ret; } if (obj != NULL) // XXX May allocate zero bytes. if (!(lis = PyMem_New(listitem_T *, slicelen * 2))) { PyErr_NoMemory(); return -1; } if (first == size) li = NULL; else { li = list_find(l, (long) first); if (li == NULL) { PyErr_VIM_FORMAT(N_("internal error: no vim list item %d"), (int)first); if (obj != NULL) PyMem_Free(lis); return -1; } i = slicelen; while (i-- && li != NULL) { j = step; next = li; if (step > 0) while (next != NULL && ((next = next->li_next) != NULL) && --j); else while (next != NULL && ((next = next->li_prev) != NULL) && ++j); if (obj == NULL) listitem_remove(l, li); else lis[slicelen - i - 1] = li; li = next; } if (li == NULL && i != -1) { PyErr_SET_VIM(N_("internal error: not enough list items")); if (obj != NULL) PyMem_Free(lis); return -1; } } if (obj == NULL) return 0; if (!(iterator = PyObject_GetIter(obj))) { PyMem_Free(lis); return -1; } i = 0; while ((item = PyIter_Next(iterator))) { if (ConvertFromPyObject(item, &v) == -1) { Py_DECREF(iterator); Py_DECREF(item); PyMem_Free(lis); return -1; } Py_DECREF(item); if (list_insert_tv(l, &v, numreplaced < slicelen ? lis[numreplaced] : li) == FAIL) { clear_tv(&v); PyErr_SET_VIM(N_("internal error: failed to add item to list")); list_restore(numadded, numreplaced, slicelen, l, lis, lastaddedli); PyMem_Free(lis); return -1; } if (numreplaced < slicelen) { lis[slicelen + numreplaced] = lis[numreplaced]->li_prev; vimlist_remove(l, lis[numreplaced], lis[numreplaced]); numreplaced++; } else { if (li) lastaddedli = li->li_prev; else lastaddedli = l->lv_last; numadded++; } clear_tv(&v); if (step != 1 && i >= slicelen) { Py_DECREF(iterator); PyErr_FORMAT(PyExc_ValueError, N_("attempt to assign sequence of size greater than %d " "to extended slice"), (int) slicelen); list_restore(numadded, numreplaced, slicelen, l, lis, lastaddedli); PyMem_Free(lis); return -1; } ++i; } Py_DECREF(iterator); if (step != 1 && i != slicelen) { PyErr_FORMAT2(PyExc_ValueError, N_("attempt to assign sequence of size %d to extended slice " "of size %d"), (int) i, (int) slicelen); list_restore(numadded, numreplaced, slicelen, l, lis, lastaddedli); PyMem_Free(lis); return -1; } if (PyErr_Occurred()) { list_restore(numadded, numreplaced, slicelen, l, lis, lastaddedli); PyMem_Free(lis); return -1; } for (i = 0; i < numreplaced; i++) listitem_free(l, lis[i]); if (step == 1) for (i = numreplaced; i < slicelen; i++) listitem_remove(l, lis[i]); PyMem_Free(lis); return 0; } static int ListAssIndex(ListObject *self, Py_ssize_t index, PyObject *obj) { typval_T tv; list_T *l = self->list; listitem_T *li; Py_ssize_t length = ListLength(self); if (l->lv_lock) { RAISE_LOCKED_LIST; return -1; } if (index > length || (index == length && obj == NULL)) { PyErr_SET_STRING(PyExc_IndexError, N_("list index out of range")); return -1; } if (obj == NULL) { li = list_find(l, (long) index); vimlist_remove(l, li, li); clear_tv(&li->li_tv); vim_free(li); return 0; } if (ConvertFromPyObject(obj, &tv) == -1) return -1; if (index == length) { if (list_append_tv(l, &tv) == FAIL) { clear_tv(&tv); PyErr_SET_VIM(N_("failed to add item to list")); return -1; } } else { li = list_find(l, (long) index); clear_tv(&li->li_tv); copy_tv(&tv, &li->li_tv); clear_tv(&tv); } return 0; } static Py_ssize_t ListAssItem(ListObject *self, PyObject *idx, PyObject *obj) { #if PY_MAJOR_VERSION < 3 if (PyInt_Check(idx)) { long _idx = PyInt_AsLong(idx); return ListAssIndex(self, _idx, obj); } else #endif if (PyLong_Check(idx)) { long _idx = PyLong_AsLong(idx); return ListAssIndex(self, _idx, obj); } else if (PySlice_Check(idx)) { Py_ssize_t start, stop, step, slicelen; if (PySlice_GetIndicesEx((PySliceObject_T *)idx, ListLength(self), &start, &stop, &step, &slicelen) < 0) return -1; return ListAssSlice(self, start, step, slicelen, obj); } else { RAISE_INVALID_INDEX_TYPE(idx); return -1; } } static PyObject * ListConcatInPlace(ListObject *self, PyObject *obj) { list_T *l = self->list; PyObject *lookup_dict; if (l->lv_lock) { RAISE_LOCKED_LIST; return NULL; } if (!(lookup_dict = PyDict_New())) return NULL; if (list_py_concat(l, obj, lookup_dict) == -1) { Py_DECREF(lookup_dict); return NULL; } Py_DECREF(lookup_dict); Py_INCREF(self); return (PyObject *)(self); } typedef struct { listwatch_T lw; list_T *list; } listiterinfo_T; static void ListIterDestruct(listiterinfo_T *lii) { list_rem_watch(lii->list, &lii->lw); PyMem_Free(lii); } static PyObject * ListIterNext(listiterinfo_T **lii) { PyObject *ret; if (!((*lii)->lw.lw_item)) return NULL; if (!(ret = ConvertToPyObject(&((*lii)->lw.lw_item->li_tv)))) return NULL; (*lii)->lw.lw_item = (*lii)->lw.lw_item->li_next; return ret; } static PyObject * ListIter(ListObject *self) { listiterinfo_T *lii; list_T *l = self->list; if (!(lii = PyMem_New(listiterinfo_T, 1))) { PyErr_NoMemory(); return NULL; } range_list_materialize(l); list_add_watch(l, &lii->lw); lii->lw.lw_item = l->lv_first; lii->list = l; return IterNew(lii, (destructorfun) ListIterDestruct, (nextfun) ListIterNext, NULL, NULL); } static char *ListAttrs[] = { "locked", NULL }; static PyObject * ListDir(PyObject *self) { return ObjectDir(self, ListAttrs); } static int ListSetattr(ListObject *self, char *name, PyObject *valObject) { if (valObject == NULL) { PyErr_SET_STRING(PyExc_AttributeError, N_("cannot delete vim.List attributes")); return -1; } if (strcmp(name, "locked") == 0) { if (self->list->lv_lock == VAR_FIXED) { PyErr_SET_STRING(PyExc_TypeError, N_("cannot modify fixed list")); return -1; } else { int istrue = PyObject_IsTrue(valObject); if (istrue == -1) return -1; else if (istrue) self->list->lv_lock = VAR_LOCKED; else self->list->lv_lock = 0; } return 0; } else { PyErr_FORMAT(PyExc_AttributeError, N_("cannot set attribute %s"), name); return -1; } } static PySequenceMethods ListAsSeq = { (lenfunc) ListLength, // sq_length, len(x) (binaryfunc) 0, // RangeConcat, sq_concat, x+y 0, // RangeRepeat, sq_repeat, x*n (PyIntArgFunc) ListIndex, // sq_item, x[i] 0, // was_sq_slice, x[i:j] (PyIntObjArgProc) ListAssIndex, // sq_as_item, x[i]=v 0, // was_sq_ass_slice, x[i:j]=v 0, // sq_contains (binaryfunc) ListConcatInPlace,// sq_inplace_concat 0, // sq_inplace_repeat }; static PyMappingMethods ListAsMapping = { /* mp_length */ (lenfunc) ListLength, /* mp_subscript */ (binaryfunc) ListItem, /* mp_ass_subscript */ (objobjargproc) ListAssItem, }; static struct PyMethodDef ListMethods[] = { {"extend", (PyCFunction)ListConcatInPlace, METH_O, ""}, {"__dir__", (PyCFunction)ListDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; typedef struct { PyObject_HEAD char_u *name; int argc; typval_T *argv; dict_T *self; pylinkedlist_T ref; int auto_rebind; } FunctionObject; static PyTypeObject FunctionType; #define NEW_FUNCTION(name, argc, argv, self, pt_auto) \ FunctionNew(&FunctionType, (name), (argc), (argv), (self), (pt_auto)) static PyObject * FunctionNew(PyTypeObject *subtype, char_u *name, int argc, typval_T *argv, dict_T *selfdict, int auto_rebind) { FunctionObject *self; self = (FunctionObject *)subtype->tp_alloc(subtype, 0); if (self == NULL) return NULL; if (isdigit(*name)) { if (!translated_function_exists(name)) { PyErr_FORMAT(PyExc_ValueError, N_("unnamed function %s does not exist"), name); return NULL; } self->name = vim_strsave(name); } else { char_u *p; if ((p = get_expanded_name(name, vim_strchr(name, AUTOLOAD_CHAR) == NULL)) == NULL) { PyErr_FORMAT(PyExc_ValueError, N_("function %s does not exist"), name); return NULL; } if (p[0] == K_SPECIAL && p[1] == KS_EXTRA && p[2] == (int)KE_SNR) { char_u *np; size_t len = STRLEN(p) + 1; if ((np = alloc(len + 2)) == NULL) { vim_free(p); return NULL; } mch_memmove(np, "<SNR>", 5); mch_memmove(np + 5, p + 3, len - 3); vim_free(p); self->name = np; } else self->name = p; } func_ref(self->name); self->argc = argc; self->argv = argv; self->self = selfdict; self->auto_rebind = selfdict == NULL ? TRUE : auto_rebind; if (self->argv || self->self) pyll_add((PyObject *)(self), &self->ref, &lastfunc); return (PyObject *)(self); } static PyObject * FunctionConstructor(PyTypeObject *subtype, PyObject *args, PyObject *kwargs) { PyObject *self; PyObject *selfdictObject; PyObject *autoRebindObject; PyObject *argsObject = NULL; char_u *name; typval_T selfdicttv; typval_T argstv; list_T *argslist = NULL; dict_T *selfdict = NULL; int argc = 0; int auto_rebind = TRUE; typval_T *argv = NULL; typval_T *curtv; listitem_T *li; if (kwargs != NULL) { selfdictObject = PyDict_GetItemString(kwargs, "self"); if (selfdictObject != NULL) { if (ConvertFromPyMapping(selfdictObject, &selfdicttv) == -1) return NULL; selfdict = selfdicttv.vval.v_dict; } argsObject = PyDict_GetItemString(kwargs, "args"); if (argsObject != NULL) { if (ConvertFromPySequence(argsObject, &argstv) == -1) { dict_unref(selfdict); return NULL; } argslist = argstv.vval.v_list; range_list_materialize(argslist); argc = argslist->lv_len; if (argc != 0) { argv = PyMem_New(typval_T, (size_t) argc); if (argv == NULL) { PyErr_NoMemory(); dict_unref(selfdict); list_unref(argslist); return NULL; } curtv = argv; for (li = argslist->lv_first; li != NULL; li = li->li_next) copy_tv(&li->li_tv, curtv++); } list_unref(argslist); } if (selfdict != NULL) { auto_rebind = FALSE; autoRebindObject = PyDict_GetItemString(kwargs, "auto_rebind"); if (autoRebindObject != NULL) { auto_rebind = PyObject_IsTrue(autoRebindObject); if (auto_rebind == -1) { dict_unref(selfdict); list_unref(argslist); return NULL; } } } } if (!PyArg_ParseTuple(args, "et", "ascii", &name)) { dict_unref(selfdict); while (argc--) clear_tv(&argv[argc]); PyMem_Free(argv); return NULL; } self = FunctionNew(subtype, name, argc, argv, selfdict, auto_rebind); PyMem_Free(name); return self; } static void FunctionDestructor(FunctionObject *self) { int i; func_unref(self->name); vim_free(self->name); for (i = 0; i < self->argc; ++i) clear_tv(&self->argv[i]); PyMem_Free(self->argv); dict_unref(self->self); if (self->argv || self->self) pyll_remove(&self->ref, &lastfunc); DESTRUCTOR_FINISH(self); } static char *FunctionAttrs[] = { "softspace", "args", "self", "auto_rebind", NULL }; static PyObject * FunctionDir(PyObject *self) { return ObjectDir(self, FunctionAttrs); } static PyObject * FunctionAttr(FunctionObject *self, char *name) { list_T *list; int i; if (strcmp(name, "name") == 0) return PyString_FromString((char *)(self->name)); else if (strcmp(name, "args") == 0) { if (self->argv == NULL || (list = list_alloc()) == NULL) return AlwaysNone(NULL); for (i = 0; i < self->argc; ++i) list_append_tv(list, &self->argv[i]); return NEW_LIST(list); } else if (strcmp(name, "self") == 0) return self->self == NULL ? AlwaysNone(NULL) : NEW_DICTIONARY(self->self); else if (strcmp(name, "auto_rebind") == 0) return self->auto_rebind ? AlwaysTrue(NULL) : AlwaysFalse(NULL); else if (strcmp(name, "__members__") == 0) return ObjectDir(NULL, FunctionAttrs); return NULL; } /* * Populate partial_T given function object. * * "exported" should be set to true when it is needed to construct a partial * that may be stored in a variable (i.e. may be freed by Vim). */ static void set_partial(FunctionObject *self, partial_T *pt, int exported) { int i; pt->pt_name = self->name; if (self->argv) { pt->pt_argc = self->argc; if (exported) { pt->pt_argv = ALLOC_CLEAR_MULT(typval_T, self->argc); for (i = 0; i < pt->pt_argc; ++i) copy_tv(&self->argv[i], &pt->pt_argv[i]); } else pt->pt_argv = self->argv; } else { pt->pt_argc = 0; pt->pt_argv = NULL; } pt->pt_auto = self->auto_rebind || !exported; pt->pt_dict = self->self; if (exported && self->self) ++pt->pt_dict->dv_refcount; if (exported) pt->pt_name = vim_strsave(pt->pt_name); pt->pt_refcount = 1; } static PyObject * FunctionCall(FunctionObject *self, PyObject *argsObject, PyObject *kwargs) { char_u *name = self->name; typval_T args; typval_T selfdicttv; typval_T rettv; dict_T *selfdict = NULL; PyObject *selfdictObject; PyObject *ret; int error; partial_T pt; partial_T *pt_ptr = NULL; if (ConvertFromPySequence(argsObject, &args) == -1) return NULL; if (kwargs != NULL) { selfdictObject = PyDict_GetItemString(kwargs, "self"); if (selfdictObject != NULL) { if (ConvertFromPyMapping(selfdictObject, &selfdicttv) == -1) { clear_tv(&args); return NULL; } selfdict = selfdicttv.vval.v_dict; } } if (self->argv || self->self) { vim_memset(&pt, 0, sizeof(partial_T)); set_partial(self, &pt, FALSE); pt_ptr = &pt; } Py_BEGIN_ALLOW_THREADS Python_Lock_Vim(); VimTryStart(); error = func_call(name, &args, pt_ptr, selfdict, &rettv); Python_Release_Vim(); Py_END_ALLOW_THREADS if (VimTryEnd()) ret = NULL; else if (error != OK) { ret = NULL; PyErr_VIM_FORMAT(N_("failed to run function %s"), (char *)name); } else ret = ConvertToPyObject(&rettv); clear_tv(&args); clear_tv(&rettv); if (selfdict != NULL) clear_tv(&selfdicttv); return ret; } static PyObject * FunctionRepr(FunctionObject *self) { PyObject *ret; garray_T repr_ga; int i; char_u *tofree = NULL; typval_T tv; char_u numbuf[NUMBUFLEN]; ga_init2(&repr_ga, (int)sizeof(char), 70); ga_concat(&repr_ga, (char_u *)"<vim.Function '"); if (self->name) ga_concat(&repr_ga, self->name); else ga_concat(&repr_ga, (char_u *)"<NULL>"); ga_append(&repr_ga, '\''); if (self->argv) { ga_concat(&repr_ga, (char_u *)", args=["); ++emsg_silent; for (i = 0; i < self->argc; i++) { if (i != 0) ga_concat(&repr_ga, (char_u *)", "); ga_concat(&repr_ga, tv2string(&self->argv[i], &tofree, numbuf, get_copyID())); vim_free(tofree); } --emsg_silent; ga_append(&repr_ga, ']'); } if (self->self) { ga_concat(&repr_ga, (char_u *)", self="); tv.v_type = VAR_DICT; tv.vval.v_dict = self->self; ++emsg_silent; ga_concat(&repr_ga, tv2string(&tv, &tofree, numbuf, get_copyID())); --emsg_silent; vim_free(tofree); if (self->auto_rebind) ga_concat(&repr_ga, (char_u *)", auto_rebind=True"); } ga_append(&repr_ga, '>'); ret = PyString_FromString((char *)repr_ga.ga_data); ga_clear(&repr_ga); return ret; } static struct PyMethodDef FunctionMethods[] = { {"__dir__", (PyCFunction)FunctionDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; /* * Options object */ static PyTypeObject OptionsType; typedef int (*checkfun)(void *); typedef struct { PyObject_HEAD int opt_type; void *from; checkfun Check; PyObject *fromObj; } OptionsObject; static int dummy_check(void *arg UNUSED) { return 0; } static PyObject * OptionsNew(int opt_type, void *from, checkfun Check, PyObject *fromObj) { OptionsObject *self; self = PyObject_GC_New(OptionsObject, &OptionsType); if (self == NULL) return NULL; self->opt_type = opt_type; self->from = from; self->Check = Check; self->fromObj = fromObj; if (fromObj) Py_INCREF(fromObj); return (PyObject *)(self); } static void OptionsDestructor(OptionsObject *self) { PyObject_GC_UnTrack((void *)(self)); Py_XDECREF(self->fromObj); PyObject_GC_Del((void *)(self)); } static int OptionsTraverse(OptionsObject *self, visitproc visit, void *arg) { Py_VISIT(self->fromObj); return 0; } static int OptionsClear(OptionsObject *self) { Py_CLEAR(self->fromObj); return 0; } static PyObject * OptionsItem(OptionsObject *self, PyObject *keyObject) { char_u *key; int flags; long numval; char_u *stringval; PyObject *todecref; if (self->Check(self->from)) return NULL; if (!(key = StringToChars(keyObject, &todecref))) return NULL; if (*key == NUL) { RAISE_NO_EMPTY_KEYS; Py_XDECREF(todecref); return NULL; } flags = get_option_value_strict(key, &numval, &stringval, self->opt_type, self->from); Py_XDECREF(todecref); if (flags == 0) { PyErr_SetObject(PyExc_KeyError, keyObject); return NULL; } if (flags & SOPT_UNSET) { Py_INCREF(Py_None); return Py_None; } else if (flags & SOPT_BOOL) { PyObject *ret; ret = numval ? Py_True : Py_False; Py_INCREF(ret); return ret; } else if (flags & SOPT_NUM) return PyInt_FromLong(numval); else if (flags & SOPT_STRING) { if (stringval) { PyObject *ret = PyBytes_FromString((char *)stringval); vim_free(stringval); return ret; } else { PyErr_SET_STRING(PyExc_RuntimeError, N_("unable to get option value")); return NULL; } } else { PyErr_SET_VIM(N_("internal error: unknown option type")); return NULL; } } static int OptionsContains(OptionsObject *self, PyObject *keyObject) { char_u *key; PyObject *todecref; if (!(key = StringToChars(keyObject, &todecref))) return -1; if (*key == NUL) { Py_XDECREF(todecref); return 0; } if (get_option_value_strict(key, NULL, NULL, self->opt_type, NULL)) { Py_XDECREF(todecref); return 1; } else { Py_XDECREF(todecref); return 0; } } typedef struct { void *lastoption; int opt_type; } optiterinfo_T; static PyObject * OptionsIterNext(optiterinfo_T **oii) { char_u *name; if ((name = option_iter_next(&((*oii)->lastoption), (*oii)->opt_type))) return PyString_FromString((char *)name); return NULL; } static PyObject * OptionsIter(OptionsObject *self) { optiterinfo_T *oii; if (!(oii = PyMem_New(optiterinfo_T, 1))) { PyErr_NoMemory(); return NULL; } oii->opt_type = self->opt_type; oii->lastoption = NULL; return IterNew(oii, (destructorfun) PyMem_Free, (nextfun) OptionsIterNext, NULL, NULL); } static int set_option_value_err(char_u *key, int numval, char_u *stringval, int opt_flags) { char *errmsg; if ((errmsg = set_option_value(key, numval, stringval, opt_flags))) { if (VimTryEnd()) return FAIL; PyErr_SetVim(errmsg); return FAIL; } return OK; } static int set_option_value_for( char_u *key, int numval, char_u *stringval, int opt_flags, int opt_type, void *from) { win_T *save_curwin = NULL; tabpage_T *save_curtab = NULL; bufref_T save_curbuf; int set_ret = 0; VimTryStart(); switch (opt_type) { case SREQ_WIN: if (switch_win(&save_curwin, &save_curtab, (win_T *)from, win_find_tabpage((win_T *)from), FALSE) == FAIL) { restore_win(save_curwin, save_curtab, TRUE); if (VimTryEnd()) return -1; PyErr_SET_VIM(N_("problem while switching windows")); return -1; } set_ret = set_option_value_err(key, numval, stringval, opt_flags); restore_win(save_curwin, save_curtab, TRUE); break; case SREQ_BUF: switch_buffer(&save_curbuf, (buf_T *)from); set_ret = set_option_value_err(key, numval, stringval, opt_flags); restore_buffer(&save_curbuf); break; case SREQ_GLOBAL: set_ret = set_option_value_err(key, numval, stringval, opt_flags); break; } if (set_ret == FAIL) return -1; return VimTryEnd(); } static int OptionsAssItem(OptionsObject *self, PyObject *keyObject, PyObject *valObject) { char_u *key; int flags; int opt_flags; int ret = 0; PyObject *todecref; if (self->Check(self->from)) return -1; if (!(key = StringToChars(keyObject, &todecref))) return -1; if (*key == NUL) { RAISE_NO_EMPTY_KEYS; Py_XDECREF(todecref); return -1; } flags = get_option_value_strict(key, NULL, NULL, self->opt_type, self->from); if (flags == 0) { PyErr_SetObject(PyExc_KeyError, keyObject); Py_XDECREF(todecref); return -1; } if (valObject == NULL) { if (self->opt_type == SREQ_GLOBAL) { PyErr_FORMAT(PyExc_ValueError, N_("unable to unset global option %s"), key); Py_XDECREF(todecref); return -1; } else if (!(flags & SOPT_GLOBAL)) { PyErr_FORMAT(PyExc_ValueError, N_("unable to unset option %s " "which does not have global value"), key); Py_XDECREF(todecref); return -1; } else { unset_global_local_option(key, self->from); Py_XDECREF(todecref); return 0; } } opt_flags = (self->opt_type ? OPT_LOCAL : OPT_GLOBAL); if (flags & SOPT_BOOL) { int istrue = PyObject_IsTrue(valObject); if (istrue == -1) ret = -1; else ret = set_option_value_for(key, istrue, NULL, opt_flags, self->opt_type, self->from); } else if (flags & SOPT_NUM) { long val; if (NumberToLong(valObject, &val, NUMBER_INT)) { Py_XDECREF(todecref); return -1; } ret = set_option_value_for(key, (int) val, NULL, opt_flags, self->opt_type, self->from); } else { char_u *val; PyObject *todecref2; if ((val = StringToChars(valObject, &todecref2))) { ret = set_option_value_for(key, 0, val, opt_flags, self->opt_type, self->from); Py_XDECREF(todecref2); } else ret = -1; } Py_XDECREF(todecref); return ret; } static PySequenceMethods OptionsAsSeq = { 0, // sq_length 0, // sq_concat 0, // sq_repeat 0, // sq_item 0, // sq_slice 0, // sq_ass_item 0, // sq_ass_slice (objobjproc) OptionsContains, // sq_contains 0, // sq_inplace_concat 0, // sq_inplace_repeat }; static PyMappingMethods OptionsAsMapping = { (lenfunc) NULL, (binaryfunc) OptionsItem, (objobjargproc) OptionsAssItem, }; // Tabpage object typedef struct { PyObject_HEAD tabpage_T *tab; } TabPageObject; static PyObject *WinListNew(TabPageObject *tabObject); static PyTypeObject TabPageType; static int CheckTabPage(TabPageObject *self) { if (self->tab == INVALID_TABPAGE_VALUE) { PyErr_SET_VIM(N_("attempt to refer to deleted tab page")); return -1; } return 0; } static PyObject * TabPageNew(tabpage_T *tab) { TabPageObject *self; if (TAB_PYTHON_REF(tab)) { self = TAB_PYTHON_REF(tab); Py_INCREF(self); } else { self = PyObject_NEW(TabPageObject, &TabPageType); if (self == NULL) return NULL; self->tab = tab; TAB_PYTHON_REF(tab) = self; } return (PyObject *)(self); } static void TabPageDestructor(TabPageObject *self) { if (self->tab && self->tab != INVALID_TABPAGE_VALUE) TAB_PYTHON_REF(self->tab) = NULL; DESTRUCTOR_FINISH(self); } static char *TabPageAttrs[] = { "windows", "number", "vars", "window", "valid", NULL }; static PyObject * TabPageDir(PyObject *self) { return ObjectDir(self, TabPageAttrs); } static PyObject * TabPageAttrValid(TabPageObject *self, char *name) { PyObject *ret; if (strcmp(name, "valid") != 0) return NULL; ret = ((self->tab == INVALID_TABPAGE_VALUE) ? Py_False : Py_True); Py_INCREF(ret); return ret; } static PyObject * TabPageAttr(TabPageObject *self, char *name) { if (strcmp(name, "windows") == 0) return WinListNew(self); else if (strcmp(name, "number") == 0) return PyLong_FromLong((long) get_tab_number(self->tab)); else if (strcmp(name, "vars") == 0) return NEW_DICTIONARY(self->tab->tp_vars); else if (strcmp(name, "window") == 0) { // For current tab window.c does not bother to set or update tp_curwin if (self->tab == curtab) return WindowNew(curwin, curtab); else return WindowNew(self->tab->tp_curwin, self->tab); } else if (strcmp(name, "__members__") == 0) return ObjectDir(NULL, TabPageAttrs); return NULL; } static PyObject * TabPageRepr(TabPageObject *self) { if (self->tab == INVALID_TABPAGE_VALUE) return PyString_FromFormat("<tabpage object (deleted) at %p>", (self)); else { int t = get_tab_number(self->tab); if (t == 0) return PyString_FromFormat("<tabpage object (unknown) at %p>", (self)); else return PyString_FromFormat("<tabpage %d>", t - 1); } } static struct PyMethodDef TabPageMethods[] = { // name, function, calling, documentation {"__dir__", (PyCFunction)TabPageDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; /* * Window list object */ static PyTypeObject TabListType; static PySequenceMethods TabListAsSeq; typedef struct { PyObject_HEAD } TabListObject; static PyInt TabListLength(PyObject *self UNUSED) { tabpage_T *tp = first_tabpage; PyInt n = 0; while (tp != NULL) { ++n; tp = tp->tp_next; } return n; } static PyObject * TabListItem(PyObject *self UNUSED, PyInt n) { tabpage_T *tp; for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, --n) if (n == 0) return TabPageNew(tp); PyErr_SET_STRING(PyExc_IndexError, N_("no such tab page")); return NULL; } /* * Window object */ typedef struct { PyObject_HEAD win_T *win; TabPageObject *tabObject; } WindowObject; static PyTypeObject WindowType; static int CheckWindow(WindowObject *self) { if (self->win == INVALID_WINDOW_VALUE) { PyErr_SET_VIM(N_("attempt to refer to deleted window")); return -1; } return 0; } static PyObject * WindowNew(win_T *win, tabpage_T *tab) { /* * We need to handle deletion of windows underneath us. * If we add a "w_python*_ref" field to the win_T structure, * then we can get at it in win_free() in vim. We then * need to create only ONE Python object per window - if * we try to create a second, just INCREF the existing one * and return it. The (single) Python object referring to * the window is stored in "w_python*_ref". * On a win_free() we set the Python object's win_T* field * to an invalid value. We trap all uses of a window * object, and reject them if the win_T* field is invalid. * * Python2 and Python3 get different fields and different objects: * w_python_ref and w_python3_ref fields respectively. */ WindowObject *self; if (WIN_PYTHON_REF(win)) { self = WIN_PYTHON_REF(win); Py_INCREF(self); } else { self = PyObject_GC_New(WindowObject, &WindowType); if (self == NULL) return NULL; self->win = win; WIN_PYTHON_REF(win) = self; } self->tabObject = ((TabPageObject *)(TabPageNew(tab))); return (PyObject *)(self); } static void WindowDestructor(WindowObject *self) { PyObject_GC_UnTrack((void *)(self)); if (self->win && self->win != INVALID_WINDOW_VALUE) WIN_PYTHON_REF(self->win) = NULL; Py_XDECREF(((PyObject *)(self->tabObject))); PyObject_GC_Del((void *)(self)); } static int WindowTraverse(WindowObject *self, visitproc visit, void *arg) { Py_VISIT(((PyObject *)(self->tabObject))); return 0; } static int WindowClear(WindowObject *self) { Py_CLEAR(self->tabObject); return 0; } static win_T * get_firstwin(TabPageObject *tabObject) { if (tabObject) { if (CheckTabPage(tabObject)) return NULL; // For current tab window.c does not bother to set or update tp_firstwin else if (tabObject->tab == curtab) return firstwin; else return tabObject->tab->tp_firstwin; } else return firstwin; } // Use the same order as in the WindowAttr() function. static char *WindowAttrs[] = { "buffer", "cursor", "height", "row", "width", "col", "vars", "options", "number", "tabpage", "valid", NULL }; static PyObject * WindowDir(PyObject *self) { return ObjectDir(self, WindowAttrs); } static PyObject * WindowAttrValid(WindowObject *self, char *name) { PyObject *ret; if (strcmp(name, "valid") != 0) return NULL; ret = ((self->win == INVALID_WINDOW_VALUE) ? Py_False : Py_True); Py_INCREF(ret); return ret; } static PyObject * WindowAttr(WindowObject *self, char *name) { if (strcmp(name, "buffer") == 0) return (PyObject *)BufferNew(self->win->w_buffer); else if (strcmp(name, "cursor") == 0) { pos_T *pos = &self->win->w_cursor; return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col)); } else if (strcmp(name, "height") == 0) return PyLong_FromLong((long)(self->win->w_height)); else if (strcmp(name, "row") == 0) return PyLong_FromLong((long)(self->win->w_winrow)); else if (strcmp(name, "width") == 0) return PyLong_FromLong((long)(self->win->w_width)); else if (strcmp(name, "col") == 0) return PyLong_FromLong((long)(self->win->w_wincol)); else if (strcmp(name, "vars") == 0) return NEW_DICTIONARY(self->win->w_vars); else if (strcmp(name, "options") == 0) return OptionsNew(SREQ_WIN, self->win, (checkfun) CheckWindow, (PyObject *) self); else if (strcmp(name, "number") == 0) { if (CheckTabPage(self->tabObject)) return NULL; return PyLong_FromLong((long) get_win_number(self->win, get_firstwin(self->tabObject))); } else if (strcmp(name, "tabpage") == 0) { Py_INCREF(self->tabObject); return (PyObject *)(self->tabObject); } else if (strcmp(name, "__members__") == 0) return ObjectDir(NULL, WindowAttrs); else return NULL; } static int WindowSetattr(WindowObject *self, char *name, PyObject *valObject) { if (CheckWindow(self)) return -1; if (strcmp(name, "buffer") == 0) { PyErr_SET_STRING(PyExc_TypeError, N_("readonly attribute: buffer")); return -1; } else if (strcmp(name, "cursor") == 0) { long lnum; long col; if (!PyArg_Parse(valObject, "(ll)", &lnum, &col)) return -1; if (lnum <= 0 || lnum > self->win->w_buffer->b_ml.ml_line_count) { PyErr_SET_VIM(N_("cursor position outside buffer")); return -1; } // Check for keyboard interrupts if (VimCheckInterrupt()) return -1; self->win->w_cursor.lnum = lnum; self->win->w_cursor.col = col; self->win->w_set_curswant = TRUE; self->win->w_cursor.coladd = 0; // When column is out of range silently correct it. check_cursor_col_win(self->win); update_screen(VALID); return 0; } else if (strcmp(name, "height") == 0) { long height; win_T *savewin; if (NumberToLong(valObject, &height, NUMBER_INT|NUMBER_UNSIGNED)) return -1; #ifdef FEAT_GUI need_mouse_correct = TRUE; #endif savewin = curwin; curwin = self->win; VimTryStart(); win_setheight((int) height); curwin = savewin; if (VimTryEnd()) return -1; return 0; } else if (strcmp(name, "width") == 0) { long width; win_T *savewin; if (NumberToLong(valObject, &width, NUMBER_INT|NUMBER_UNSIGNED)) return -1; #ifdef FEAT_GUI need_mouse_correct = TRUE; #endif savewin = curwin; curwin = self->win; VimTryStart(); win_setwidth((int) width); curwin = savewin; if (VimTryEnd()) return -1; return 0; } else { PyErr_SetString(PyExc_AttributeError, name); return -1; } } static PyObject * WindowRepr(WindowObject *self) { if (self->win == INVALID_WINDOW_VALUE) return PyString_FromFormat("<window object (deleted) at %p>", (self)); else { int w = get_win_number(self->win, firstwin); if (w == 0) return PyString_FromFormat("<window object (unknown) at %p>", (self)); else return PyString_FromFormat("<window %d>", w - 1); } } static struct PyMethodDef WindowMethods[] = { // name, function, calling, documentation {"__dir__", (PyCFunction)WindowDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; /* * Window list object */ static PyTypeObject WinListType; static PySequenceMethods WinListAsSeq; typedef struct { PyObject_HEAD TabPageObject *tabObject; } WinListObject; static PyObject * WinListNew(TabPageObject *tabObject) { WinListObject *self; self = PyObject_NEW(WinListObject, &WinListType); self->tabObject = tabObject; Py_INCREF(tabObject); return (PyObject *)(self); } static void WinListDestructor(WinListObject *self) { TabPageObject *tabObject = self->tabObject; if (tabObject) { Py_DECREF((PyObject *)(tabObject)); } DESTRUCTOR_FINISH(self); } static PyInt WinListLength(WinListObject *self) { win_T *w; PyInt n = 0; if (!(w = get_firstwin(self->tabObject))) return -1; while (w != NULL) { ++n; w = W_NEXT(w); } return n; } static PyObject * WinListItem(WinListObject *self, PyInt n) { win_T *w; if (!(w = get_firstwin(self->tabObject))) return NULL; for (; w != NULL; w = W_NEXT(w), --n) if (n == 0) return WindowNew(w, self->tabObject? self->tabObject->tab: curtab); PyErr_SET_STRING(PyExc_IndexError, N_("no such window")); return NULL; } /* * Convert a Python string into a Vim line. * * The result is in allocated memory. All internal nulls are replaced by * newline characters. It is an error for the string to contain newline * characters. * * On errors, the Python exception data is set, and NULL is returned. */ static char * StringToLine(PyObject *obj) { char *str; char *save; PyObject *bytes = NULL; Py_ssize_t len = 0; PyInt i; char *p; if (PyBytes_Check(obj)) { if (PyBytes_AsStringAndSize(obj, &str, &len) == -1 || str == NULL) return NULL; } else if (PyUnicode_Check(obj)) { if (!(bytes = PyUnicode_AsEncodedString(obj, ENC_OPT, NULL))) return NULL; if (PyBytes_AsStringAndSize(bytes, &str, &len) == -1 || str == NULL) { Py_DECREF(bytes); return NULL; } } else { #if PY_MAJOR_VERSION < 3 PyErr_FORMAT(PyExc_TypeError, N_("expected str() or unicode() instance, but got %s"), Py_TYPE_NAME(obj)); #else PyErr_FORMAT(PyExc_TypeError, N_("expected bytes() or str() instance, but got %s"), Py_TYPE_NAME(obj)); #endif return NULL; } /* * Error checking: String must not contain newlines, as we * are replacing a single line, and we must replace it with * a single line. * A trailing newline is removed, so that append(f.readlines()) works. */ p = memchr(str, '\n', len); if (p != NULL) { if (p == str + len - 1) --len; else { PyErr_SET_VIM(N_("string cannot contain newlines")); Py_XDECREF(bytes); return NULL; } } /* * Create a copy of the string, with internal nulls replaced by * newline characters, as is the vim convention. */ save = alloc(len+1); if (save == NULL) { PyErr_NoMemory(); Py_XDECREF(bytes); return NULL; } for (i = 0; i < len; ++i) { if (str[i] == '\0') save[i] = '\n'; else save[i] = str[i]; } save[i] = '\0'; Py_XDECREF(bytes); // Python 2 does nothing here return save; } /* * Get a line from the specified buffer. The line number is * in Vim format (1-based). The line is returned as a Python * string object. */ static PyObject * GetBufferLine(buf_T *buf, PyInt n) { return LineToString((char *)ml_get_buf(buf, (linenr_T)n, FALSE)); } /* * Get a list of lines from the specified buffer. The line numbers * are in Vim format (1-based). The range is from lo up to, but not * including, hi. The list is returned as a Python list of string objects. */ static PyObject * GetBufferLineList(buf_T *buf, PyInt lo, PyInt hi) { PyInt i; PyInt n = hi - lo; PyObject *list = PyList_New(n); if (list == NULL) return NULL; for (i = 0; i < n; ++i) { PyObject *string = LineToString( (char *)ml_get_buf(buf, (linenr_T)(lo+i), FALSE)); // Error check - was the Python string creation OK? if (string == NULL) { Py_DECREF(list); return NULL; } PyList_SET_ITEM(list, i, string); } // The ownership of the Python list is passed to the caller (ie, // the caller should Py_DECREF() the object when it is finished // with it). return list; } /* * Check if deleting lines made the cursor position invalid. * Changed the lines from "lo" to "hi" and added "extra" lines (negative if * deleted). */ static void py_fix_cursor(linenr_T lo, linenr_T hi, linenr_T extra) { if (curwin->w_cursor.lnum >= lo) { // Adjust the cursor position if it's in/after the changed // lines. if (curwin->w_cursor.lnum >= hi) { curwin->w_cursor.lnum += extra; check_cursor_col(); } else if (extra < 0) { curwin->w_cursor.lnum = lo; check_cursor(); } else check_cursor_col(); changed_cline_bef_curs(); } invalidate_botline(); } /* * Replace a line in the specified buffer. The line number is * in Vim format (1-based). The replacement line is given as * a Python string object. The object is checked for validity * and correct format. Errors are returned as a value of FAIL. * The return value is OK on success. * If OK is returned and len_change is not NULL, *len_change * is set to the change in the buffer length. */ static int SetBufferLine(buf_T *buf, PyInt n, PyObject *line, PyInt *len_change) { bufref_T save_curbuf = {NULL, 0, 0}; win_T *save_curwin = NULL; tabpage_T *save_curtab = NULL; // First of all, we check the type of the supplied Python object. // There are three cases: // 1. NULL, or None - this is a deletion. // 2. A string - this is a replacement. // 3. Anything else - this is an error. if (line == Py_None || line == NULL) { PyErr_Clear(); switch_to_win_for_buf(buf, &save_curwin, &save_curtab, &save_curbuf); VimTryStart(); if (u_savedel((linenr_T)n, 1L) == FAIL) RAISE_UNDO_FAIL; else if (ml_delete((linenr_T)n, FALSE) == FAIL) RAISE_DELETE_LINE_FAIL; else { if (buf == curbuf && (save_curwin != NULL || save_curbuf.br_buf == NULL)) // Using an existing window for the buffer, adjust the cursor // position. py_fix_cursor((linenr_T)n, (linenr_T)n + 1, (linenr_T)-1); if (save_curbuf.br_buf == NULL) // Only adjust marks if we managed to switch to a window that // holds the buffer, otherwise line numbers will be invalid. deleted_lines_mark((linenr_T)n, 1L); } restore_win_for_buf(save_curwin, save_curtab, &save_curbuf); if (VimTryEnd()) return FAIL; if (len_change) *len_change = -1; return OK; } else if (PyBytes_Check(line) || PyUnicode_Check(line)) { char *save = StringToLine(line); if (save == NULL) return FAIL; VimTryStart(); // We do not need to free "save" if ml_replace() consumes it. PyErr_Clear(); switch_to_win_for_buf(buf, &save_curwin, &save_curtab, &save_curbuf); if (u_savesub((linenr_T)n) == FAIL) { RAISE_UNDO_FAIL; vim_free(save); } else if (ml_replace((linenr_T)n, (char_u *)save, FALSE) == FAIL) { RAISE_REPLACE_LINE_FAIL; vim_free(save); } else changed_bytes((linenr_T)n, 0); restore_win_for_buf(save_curwin, save_curtab, &save_curbuf); // Check that the cursor is not beyond the end of the line now. if (buf == curbuf) check_cursor_col(); if (VimTryEnd()) return FAIL; if (len_change) *len_change = 0; return OK; } else { PyErr_BadArgument(); return FAIL; } } /* * Replace a range of lines in the specified buffer. The line numbers are in * Vim format (1-based). The range is from lo up to, but not including, hi. * The replacement lines are given as a Python list of string objects. The * list is checked for validity and correct format. Errors are returned as a * value of FAIL. The return value is OK on success. * If OK is returned and len_change is not NULL, *len_change * is set to the change in the buffer length. */ static int SetBufferLineList( buf_T *buf, PyInt lo, PyInt hi, PyObject *list, PyInt *len_change) { bufref_T save_curbuf = {NULL, 0, 0}; win_T *save_curwin = NULL; tabpage_T *save_curtab = NULL; // First of all, we check the type of the supplied Python object. // There are three cases: // 1. NULL, or None - this is a deletion. // 2. A list - this is a replacement. // 3. Anything else - this is an error. if (list == Py_None || list == NULL) { PyInt i; PyInt n = (int)(hi - lo); PyErr_Clear(); VimTryStart(); switch_to_win_for_buf(buf, &save_curwin, &save_curtab, &save_curbuf); if (u_savedel((linenr_T)lo, (long)n) == FAIL) RAISE_UNDO_FAIL; else { for (i = 0; i < n; ++i) { if (ml_delete((linenr_T)lo, FALSE) == FAIL) { RAISE_DELETE_LINE_FAIL; break; } } if (buf == curbuf && (save_curwin != NULL || save_curbuf.br_buf == NULL)) // Using an existing window for the buffer, adjust the cursor // position. py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)-n); if (save_curbuf.br_buf == NULL) // Only adjust marks if we managed to switch to a window that // holds the buffer, otherwise line numbers will be invalid. deleted_lines_mark((linenr_T)lo, (long)i); } restore_win_for_buf(save_curwin, save_curtab, &save_curbuf); if (VimTryEnd()) return FAIL; if (len_change) *len_change = -n; return OK; } else if (PyList_Check(list)) { PyInt i; PyInt new_len = PyList_Size(list); PyInt old_len = hi - lo; PyInt extra = 0; // lines added to text, can be negative char **array; if (new_len == 0) // avoid allocating zero bytes array = NULL; else { array = PyMem_New(char *, new_len); if (array == NULL) { PyErr_NoMemory(); return FAIL; } } for (i = 0; i < new_len; ++i) { PyObject *line; if (!(line = PyList_GetItem(list, i)) || !(array[i] = StringToLine(line))) { while (i) vim_free(array[--i]); PyMem_Free(array); return FAIL; } } VimTryStart(); PyErr_Clear(); // START of region without "return". Must call restore_buffer()! switch_to_win_for_buf(buf, &save_curwin, &save_curtab, &save_curbuf); if (u_save((linenr_T)(lo-1), (linenr_T)hi) == FAIL) RAISE_UNDO_FAIL; // If the size of the range is reducing (ie, new_len < old_len) we // need to delete some old_len. We do this at the start, by // repeatedly deleting line "lo". if (!PyErr_Occurred()) { for (i = 0; i < old_len - new_len; ++i) if (ml_delete((linenr_T)lo, FALSE) == FAIL) { RAISE_DELETE_LINE_FAIL; break; } extra -= i; } // For as long as possible, replace the existing old_len with the // new old_len. This is a more efficient operation, as it requires // less memory allocation and freeing. if (!PyErr_Occurred()) { for (i = 0; i < old_len && i < new_len; ++i) if (ml_replace((linenr_T)(lo+i), (char_u *)array[i], FALSE) == FAIL) { RAISE_REPLACE_LINE_FAIL; break; } } else i = 0; // Now we may need to insert the remaining new old_len. If we do, we // must free the strings as we finish with them (we can't pass the // responsibility to vim in this case). if (!PyErr_Occurred()) { while (i < new_len) { if (ml_append((linenr_T)(lo + i - 1), (char_u *)array[i], 0, FALSE) == FAIL) { RAISE_INSERT_LINE_FAIL; break; } vim_free(array[i]); ++i; ++extra; } } // Free any left-over old_len, as a result of an error while (i < new_len) { vim_free(array[i]); ++i; } // Free the array of old_len. All of its contents have now // been dealt with (either freed, or the responsibility passed // to vim. PyMem_Free(array); // Adjust marks. Invalidate any which lie in the // changed range, and move any in the remainder of the buffer. // Only adjust marks if we managed to switch to a window that holds // the buffer, otherwise line numbers will be invalid. if (save_curbuf.br_buf == NULL) mark_adjust((linenr_T)lo, (linenr_T)(hi - 1), (long)MAXLNUM, (long)extra); changed_lines((linenr_T)lo, 0, (linenr_T)hi, (long)extra); if (buf == curbuf && (save_curwin != NULL || save_curbuf.br_buf == NULL)) // Using an existing window for the buffer, adjust the cursor // position. py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)extra); // END of region without "return". restore_win_for_buf(save_curwin, save_curtab, &save_curbuf); if (VimTryEnd()) return FAIL; if (len_change) *len_change = new_len - old_len; return OK; } else { PyErr_BadArgument(); return FAIL; } } /* * Insert a number of lines into the specified buffer after the specified line. * The line number is in Vim format (1-based). The lines to be inserted are * given as a Python list of string objects or as a single string. The lines * to be added are checked for validity and correct format. Errors are * returned as a value of FAIL. The return value is OK on success. * If OK is returned and len_change is not NULL, *len_change * is set to the change in the buffer length. */ static int InsertBufferLines(buf_T *buf, PyInt n, PyObject *lines, PyInt *len_change) { bufref_T save_curbuf = {NULL, 0, 0}; win_T *save_curwin = NULL; tabpage_T *save_curtab = NULL; // First of all, we check the type of the supplied Python object. // It must be a string or a list, or the call is in error. if (PyBytes_Check(lines) || PyUnicode_Check(lines)) { char *str = StringToLine(lines); if (str == NULL) return FAIL; PyErr_Clear(); VimTryStart(); switch_to_win_for_buf(buf, &save_curwin, &save_curtab, &save_curbuf); if (u_save((linenr_T)n, (linenr_T)(n + 1)) == FAIL) RAISE_UNDO_FAIL; else if (ml_append((linenr_T)n, (char_u *)str, 0, FALSE) == FAIL) RAISE_INSERT_LINE_FAIL; else if (save_curbuf.br_buf == NULL) // Only adjust marks if we managed to switch to a window that // holds the buffer, otherwise line numbers will be invalid. appended_lines_mark((linenr_T)n, 1L); vim_free(str); restore_win_for_buf(save_curwin, save_curtab, &save_curbuf); update_screen(VALID); if (VimTryEnd()) return FAIL; if (len_change) *len_change = 1; return OK; } else if (PyList_Check(lines)) { PyInt i; PyInt size = PyList_Size(lines); char **array; array = PyMem_New(char *, size); if (array == NULL) { PyErr_NoMemory(); return FAIL; } for (i = 0; i < size; ++i) { PyObject *line; if (!(line = PyList_GetItem(lines, i)) || !(array[i] = StringToLine(line))) { while (i) vim_free(array[--i]); PyMem_Free(array); return FAIL; } } PyErr_Clear(); VimTryStart(); switch_to_win_for_buf(buf, &save_curwin, &save_curtab, &save_curbuf); if (u_save((linenr_T)n, (linenr_T)(n + 1)) == FAIL) RAISE_UNDO_FAIL; else { for (i = 0; i < size; ++i) { if (ml_append((linenr_T)(n + i), (char_u *)array[i], 0, FALSE) == FAIL) { RAISE_INSERT_LINE_FAIL; // Free the rest of the lines while (i < size) vim_free(array[i++]); break; } vim_free(array[i]); } if (i > 0 && save_curbuf.br_buf == NULL) // Only adjust marks if we managed to switch to a window that // holds the buffer, otherwise line numbers will be invalid. appended_lines_mark((linenr_T)n, (long)i); } // Free the array of lines. All of its contents have now // been freed. PyMem_Free(array); restore_win_for_buf(save_curwin, save_curtab, &save_curbuf); update_screen(VALID); if (VimTryEnd()) return FAIL; if (len_change) *len_change = size; return OK; } else { PyErr_BadArgument(); return FAIL; } } /* * Common routines for buffers and line ranges * ------------------------------------------- */ typedef struct { PyObject_HEAD buf_T *buf; } BufferObject; static int CheckBuffer(BufferObject *self) { if (self->buf == INVALID_BUFFER_VALUE) { PyErr_SET_VIM(N_("attempt to refer to deleted buffer")); return -1; } return 0; } static PyObject * RBItem(BufferObject *self, PyInt n, PyInt start, PyInt end) { if (CheckBuffer(self)) return NULL; if (end == -1) end = self->buf->b_ml.ml_line_count; if (n < 0) n += end - start + 1; if (n < 0 || n > end - start) { PyErr_SET_STRING(PyExc_IndexError, N_("line number out of range")); return NULL; } return GetBufferLine(self->buf, n+start); } static PyObject * RBSlice(BufferObject *self, PyInt lo, PyInt hi, PyInt start, PyInt end) { PyInt size; if (CheckBuffer(self)) return NULL; if (end == -1) end = self->buf->b_ml.ml_line_count; size = end - start + 1; if (lo < 0) lo = 0; else if (lo > size) lo = size; if (hi < 0) hi = 0; if (hi < lo) hi = lo; else if (hi > size) hi = size; return GetBufferLineList(self->buf, lo+start, hi+start); } static PyInt RBAsItem( BufferObject *self, PyInt n, PyObject *valObject, PyInt start, PyInt end, PyInt *new_end) { PyInt len_change; if (CheckBuffer(self)) return -1; if (end == -1) end = self->buf->b_ml.ml_line_count; if (n < 0) n += end - start + 1; if (n < 0 || n > end - start) { PyErr_SET_STRING(PyExc_IndexError, N_("line number out of range")); return -1; } if (SetBufferLine(self->buf, n+start, valObject, &len_change) == FAIL) return -1; if (new_end) *new_end = end + len_change; return 0; } static PyInt RBAsSlice( BufferObject *self, PyInt lo, PyInt hi, PyObject *valObject, PyInt start, PyInt end, PyInt *new_end) { PyInt size; PyInt len_change; // Self must be a valid buffer if (CheckBuffer(self)) return -1; if (end == -1) end = self->buf->b_ml.ml_line_count; // Sort out the slice range size = end - start + 1; if (lo < 0) lo = 0; else if (lo > size) lo = size; if (hi < 0) hi = 0; if (hi < lo) hi = lo; else if (hi > size) hi = size; if (SetBufferLineList(self->buf, lo + start, hi + start, valObject, &len_change) == FAIL) return -1; if (new_end) *new_end = end + len_change; return 0; } static PyObject * RBAppend( BufferObject *self, PyObject *args, PyInt start, PyInt end, PyInt *new_end) { PyObject *lines; PyInt len_change; PyInt max; PyInt n; if (CheckBuffer(self)) return NULL; if (end == -1) end = self->buf->b_ml.ml_line_count; max = n = end - start + 1; if (!PyArg_ParseTuple(args, "O|n", &lines, &n)) return NULL; if (n < 0 || n > max) { PyErr_SET_STRING(PyExc_IndexError, N_("line number out of range")); return NULL; } if (InsertBufferLines(self->buf, n + start - 1, lines, &len_change) == FAIL) return NULL; if (new_end) *new_end = end + len_change; Py_INCREF(Py_None); return Py_None; } // Range object static PyTypeObject RangeType; static PySequenceMethods RangeAsSeq; static PyMappingMethods RangeAsMapping; typedef struct { PyObject_HEAD BufferObject *buf; PyInt start; PyInt end; } RangeObject; static PyObject * RangeNew(buf_T *buf, PyInt start, PyInt end) { BufferObject *bufr; RangeObject *self; self = PyObject_GC_New(RangeObject, &RangeType); if (self == NULL) return NULL; bufr = (BufferObject *)BufferNew(buf); if (bufr == NULL) { Py_DECREF(self); return NULL; } Py_INCREF(bufr); self->buf = bufr; self->start = start; self->end = end; return (PyObject *)(self); } static void RangeDestructor(RangeObject *self) { PyObject_GC_UnTrack((void *)(self)); Py_XDECREF(self->buf); PyObject_GC_Del((void *)(self)); } static int RangeTraverse(RangeObject *self, visitproc visit, void *arg) { Py_VISIT(((PyObject *)(self->buf))); return 0; } static int RangeClear(RangeObject *self) { Py_CLEAR(self->buf); return 0; } static PyInt RangeLength(RangeObject *self) { // HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? if (CheckBuffer(self->buf)) return -1; // ??? return (self->end - self->start + 1); } static PyObject * RangeItem(RangeObject *self, PyInt n) { return RBItem(self->buf, n, self->start, self->end); } static PyObject * RangeSlice(RangeObject *self, PyInt lo, PyInt hi) { return RBSlice(self->buf, lo, hi, self->start, self->end); } static char *RangeAttrs[] = { "start", "end", NULL }; static PyObject * RangeDir(PyObject *self) { return ObjectDir(self, RangeAttrs); } static PyObject * RangeAppend(RangeObject *self, PyObject *args) { return RBAppend(self->buf, args, self->start, self->end, &self->end); } static PyObject * RangeRepr(RangeObject *self) { if (self->buf->buf == INVALID_BUFFER_VALUE) return PyString_FromFormat("<range object (for deleted buffer) at %p>", (self)); else { char *name = (char *)self->buf->buf->b_fname; if (name == NULL) name = ""; return PyString_FromFormat("<range %s (%d:%d)>", name, (int)self->start, (int)self->end); } } static struct PyMethodDef RangeMethods[] = { // name, function, calling, documentation {"append", (PyCFunction)RangeAppend, METH_VARARGS, "Append data to the Vim range" }, {"__dir__", (PyCFunction)RangeDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; static PyTypeObject BufferType; static PySequenceMethods BufferAsSeq; static PyMappingMethods BufferAsMapping; static PyObject * BufferNew(buf_T *buf) { /* * We need to handle deletion of buffers underneath us. * If we add a "b_python*_ref" field to the buf_T structure, * then we can get at it in buf_freeall() in vim. We then * need to create only ONE Python object per buffer - if * we try to create a second, just INCREF the existing one * and return it. The (single) Python object referring to * the buffer is stored in "b_python*_ref". * Question: what to do on a buf_freeall(). We'll probably * have to either delete the Python object (DECREF it to * zero - a bad idea, as it leaves dangling refs!) or * set the buf_T * value to an invalid value (-1?), which * means we need checks in all access functions... Bah. * * Python2 and Python3 get different fields and different objects: * b_python_ref and b_python3_ref fields respectively. */ BufferObject *self; if (BUF_PYTHON_REF(buf) != NULL) { self = BUF_PYTHON_REF(buf); Py_INCREF(self); } else { self = PyObject_NEW(BufferObject, &BufferType); if (self == NULL) return NULL; self->buf = buf; BUF_PYTHON_REF(buf) = self; } return (PyObject *)(self); } static void BufferDestructor(BufferObject *self) { if (self->buf && self->buf != INVALID_BUFFER_VALUE) BUF_PYTHON_REF(self->buf) = NULL; DESTRUCTOR_FINISH(self); } static PyInt BufferLength(BufferObject *self) { // HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? if (CheckBuffer(self)) return -1; // ??? return (PyInt)(self->buf->b_ml.ml_line_count); } static PyObject * BufferItem(BufferObject *self, PyInt n) { return RBItem(self, n, 1, -1); } static PyObject * BufferSlice(BufferObject *self, PyInt lo, PyInt hi) { return RBSlice(self, lo, hi, 1, -1); } static char *BufferAttrs[] = { "name", "number", "vars", "options", "valid", NULL }; static PyObject * BufferDir(PyObject *self) { return ObjectDir(self, BufferAttrs); } static PyObject * BufferAttrValid(BufferObject *self, char *name) { PyObject *ret; if (strcmp(name, "valid") != 0) return NULL; ret = ((self->buf == INVALID_BUFFER_VALUE) ? Py_False : Py_True); Py_INCREF(ret); return ret; } static PyObject * BufferAttr(BufferObject *self, char *name) { if (strcmp(name, "name") == 0) return PyString_FromString((self->buf->b_ffname == NULL ? "" : (char *)self->buf->b_ffname)); else if (strcmp(name, "number") == 0) return Py_BuildValue(Py_ssize_t_fmt, self->buf->b_fnum); else if (strcmp(name, "vars") == 0) return NEW_DICTIONARY(self->buf->b_vars); else if (strcmp(name, "options") == 0) return OptionsNew(SREQ_BUF, self->buf, (checkfun) CheckBuffer, (PyObject *) self); else if (strcmp(name, "__members__") == 0) return ObjectDir(NULL, BufferAttrs); else return NULL; } static int BufferSetattr(BufferObject *self, char *name, PyObject *valObject) { if (CheckBuffer(self)) return -1; if (strcmp(name, "name") == 0) { char_u *val; aco_save_T aco; int ren_ret; PyObject *todecref; if (!(val = StringToChars(valObject, &todecref))) return -1; VimTryStart(); // Using aucmd_*: autocommands will be executed by rename_buffer aucmd_prepbuf(&aco, self->buf); ren_ret = rename_buffer(val); aucmd_restbuf(&aco); Py_XDECREF(todecref); if (VimTryEnd()) return -1; if (ren_ret == FAIL) { PyErr_SET_VIM(N_("failed to rename buffer")); return -1; } return 0; } else { PyErr_SetString(PyExc_AttributeError, name); return -1; } } static PyObject * BufferAppend(BufferObject *self, PyObject *args) { return RBAppend(self, args, 1, -1, NULL); } static PyObject * BufferMark(BufferObject *self, PyObject *pmarkObject) { pos_T *posp; char_u *pmark; char_u mark; bufref_T savebuf; PyObject *todecref; if (CheckBuffer(self)) return NULL; if (!(pmark = StringToChars(pmarkObject, &todecref))) return NULL; if (pmark[0] == '\0' || pmark[1] != '\0') { PyErr_SET_STRING(PyExc_ValueError, N_("mark name must be a single character")); Py_XDECREF(todecref); return NULL; } mark = *pmark; Py_XDECREF(todecref); VimTryStart(); switch_buffer(&savebuf, self->buf); posp = getmark(mark, FALSE); restore_buffer(&savebuf); if (VimTryEnd()) return NULL; if (posp == NULL) { PyErr_SET_VIM(N_("invalid mark name")); return NULL; } if (posp->lnum <= 0) { // Or raise an error? Py_INCREF(Py_None); return Py_None; } return Py_BuildValue("(ll)", (long)(posp->lnum), (long)(posp->col)); } static PyObject * BufferRange(BufferObject *self, PyObject *args) { PyInt start; PyInt end; if (CheckBuffer(self)) return NULL; if (!PyArg_ParseTuple(args, "nn", &start, &end)) return NULL; return RangeNew(self->buf, start, end); } static PyObject * BufferRepr(BufferObject *self) { if (self->buf == INVALID_BUFFER_VALUE) return PyString_FromFormat("<buffer object (deleted) at %p>", self); else { char *name = (char *)self->buf->b_fname; if (name == NULL) name = ""; return PyString_FromFormat("<buffer %s>", name); } } static struct PyMethodDef BufferMethods[] = { // name, function, calling, documentation {"append", (PyCFunction)BufferAppend, METH_VARARGS, "Append data to Vim buffer" }, {"mark", (PyCFunction)BufferMark, METH_O, "Return (row,col) representing position of named mark" }, {"range", (PyCFunction)BufferRange, METH_VARARGS, "Return a range object which represents the part of the given buffer between line numbers s and e" }, {"__dir__", (PyCFunction)BufferDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; /* * Buffer list object - Implementation */ static PyTypeObject BufMapType; typedef struct { PyObject_HEAD } BufMapObject; static PyInt BufMapLength(PyObject *self UNUSED) { buf_T *b = firstbuf; PyInt n = 0; while (b) { ++n; b = b->b_next; } return n; } static PyObject * BufMapItem(PyObject *self UNUSED, PyObject *keyObject) { buf_T *b; long bnr; if (NumberToLong(keyObject, &bnr, NUMBER_INT|NUMBER_NATURAL)) return NULL; b = buflist_findnr((int) bnr); if (b) return BufferNew(b); else { PyErr_SetObject(PyExc_KeyError, keyObject); return NULL; } } static void BufMapIterDestruct(PyObject *buffer) { // Iteration was stopped before all buffers were processed if (buffer) { Py_DECREF(buffer); } } static int BufMapIterTraverse(PyObject *buffer, visitproc visit, void *arg) { if (buffer) Py_VISIT(buffer); return 0; } static int BufMapIterClear(PyObject **buffer) { if (*buffer) Py_CLEAR(*buffer); return 0; } static PyObject * BufMapIterNext(PyObject **buffer) { PyObject *next; PyObject *ret; if (!*buffer) return NULL; ret = *buffer; if (CheckBuffer((BufferObject *)(ret))) { *buffer = NULL; return NULL; } if (!((BufferObject *)(ret))->buf->b_next) next = NULL; else if (!(next = BufferNew(((BufferObject *)(ret))->buf->b_next))) return NULL; *buffer = next; // Do not increment reference: we no longer hold it (decref), but whoever // on other side will hold (incref). Decref+incref = nothing. return ret; } static PyObject * BufMapIter(PyObject *self UNUSED) { PyObject *buffer; buffer = BufferNew(firstbuf); return IterNew(buffer, (destructorfun) BufMapIterDestruct, (nextfun) BufMapIterNext, (traversefun) BufMapIterTraverse, (clearfun) BufMapIterClear); } static PyMappingMethods BufMapAsMapping = { (lenfunc) BufMapLength, (binaryfunc) BufMapItem, (objobjargproc) 0, }; // Current items object static char *CurrentAttrs[] = { "buffer", "window", "line", "range", "tabpage", NULL }; static PyObject * CurrentDir(PyObject *self) { return ObjectDir(self, CurrentAttrs); } static PyObject * CurrentGetattr(PyObject *self UNUSED, char *name) { if (strcmp(name, "buffer") == 0) return (PyObject *)BufferNew(curbuf); else if (strcmp(name, "window") == 0) return (PyObject *)WindowNew(curwin, curtab); else if (strcmp(name, "tabpage") == 0) return (PyObject *)TabPageNew(curtab); else if (strcmp(name, "line") == 0) return GetBufferLine(curbuf, (PyInt)curwin->w_cursor.lnum); else if (strcmp(name, "range") == 0) return RangeNew(curbuf, RangeStart, RangeEnd); else if (strcmp(name, "__members__") == 0) return ObjectDir(NULL, CurrentAttrs); else #if PY_MAJOR_VERSION < 3 return Py_FindMethod(WindowMethods, self, name); #else return NULL; #endif } static int CurrentSetattr(PyObject *self UNUSED, char *name, PyObject *valObject) { if (strcmp(name, "line") == 0) { if (SetBufferLine(curbuf, (PyInt)curwin->w_cursor.lnum, valObject, NULL) == FAIL) return -1; return 0; } else if (strcmp(name, "buffer") == 0) { int count; if (valObject->ob_type != &BufferType) { PyErr_FORMAT(PyExc_TypeError, N_("expected vim.Buffer object, but got %s"), Py_TYPE_NAME(valObject)); return -1; } if (CheckBuffer((BufferObject *)(valObject))) return -1; count = ((BufferObject *)(valObject))->buf->b_fnum; VimTryStart(); if (do_buffer(DOBUF_GOTO, DOBUF_FIRST, FORWARD, count, 0) == FAIL) { if (VimTryEnd()) return -1; PyErr_VIM_FORMAT(N_("failed to switch to buffer %d"), count); return -1; } return VimTryEnd(); } else if (strcmp(name, "window") == 0) { int count; if (valObject->ob_type != &WindowType) { PyErr_FORMAT(PyExc_TypeError, N_("expected vim.Window object, but got %s"), Py_TYPE_NAME(valObject)); return -1; } if (CheckWindow((WindowObject *)(valObject))) return -1; count = get_win_number(((WindowObject *)(valObject))->win, firstwin); if (!count) { PyErr_SET_STRING(PyExc_ValueError, N_("failed to find window in the current tab page")); return -1; } VimTryStart(); win_goto(((WindowObject *)(valObject))->win); if (((WindowObject *)(valObject))->win != curwin) { if (VimTryEnd()) return -1; PyErr_SET_STRING(PyExc_RuntimeError, N_("did not switch to the specified window")); return -1; } return VimTryEnd(); } else if (strcmp(name, "tabpage") == 0) { if (valObject->ob_type != &TabPageType) { PyErr_FORMAT(PyExc_TypeError, N_("expected vim.TabPage object, but got %s"), Py_TYPE_NAME(valObject)); return -1; } if (CheckTabPage((TabPageObject *)(valObject))) return -1; VimTryStart(); goto_tabpage_tp(((TabPageObject *)(valObject))->tab, TRUE, TRUE); if (((TabPageObject *)(valObject))->tab != curtab) { if (VimTryEnd()) return -1; PyErr_SET_STRING(PyExc_RuntimeError, N_("did not switch to the specified tab page")); return -1; } return VimTryEnd(); } else { PyErr_SetString(PyExc_AttributeError, name); return -1; } } static struct PyMethodDef CurrentMethods[] = { // name, function, calling, documentation {"__dir__", (PyCFunction)CurrentDir, METH_NOARGS, ""}, { NULL, NULL, 0, NULL} }; static void init_range_cmd(exarg_T *eap) { RangeStart = eap->line1; RangeEnd = eap->line2; } static void init_range_eval(typval_T *rettv UNUSED) { RangeStart = (PyInt) curwin->w_cursor.lnum; RangeEnd = RangeStart; } static void run_cmd(const char *cmd, void *arg UNUSED #ifdef PY_CAN_RECURSE , PyGILState_STATE *pygilstate UNUSED #endif ) { PyObject *run_ret; run_ret = PyRun_String((char *)cmd, Py_file_input, globals, globals); if (run_ret != NULL) { Py_DECREF(run_ret); } else if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SystemExit)) { semsg(_(e_py_systemexit), "python"); PyErr_Clear(); } else PyErr_PrintEx(1); } static const char *code_hdr = "def " DOPY_FUNC "(line, linenr):\n "; static int code_hdr_len = 30; static void run_do(const char *cmd, void *arg UNUSED #ifdef PY_CAN_RECURSE , PyGILState_STATE *pygilstate #endif ) { PyInt lnum; size_t len; char *code; int status; PyObject *pyfunc, *pymain; PyObject *run_ret; buf_T *was_curbuf = curbuf; if (u_save((linenr_T)RangeStart - 1, (linenr_T)RangeEnd + 1) != OK) { emsg(_("cannot save undo information")); return; } len = code_hdr_len + STRLEN(cmd); code = PyMem_New(char, len + 1); memcpy(code, code_hdr, code_hdr_len); STRCPY(code + code_hdr_len, cmd); run_ret = PyRun_String(code, Py_file_input, globals, globals); status = -1; if (run_ret != NULL) { status = 0; Py_DECREF(run_ret); } else if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SystemExit)) { PyMem_Free(code); semsg(_(e_py_systemexit), "python"); PyErr_Clear(); return; } else PyErr_PrintEx(1); PyMem_Free(code); if (status) { emsg(_("failed to run the code")); return; } status = 0; pymain = PyImport_AddModule("__main__"); pyfunc = PyObject_GetAttrString(pymain, DOPY_FUNC); #ifdef PY_CAN_RECURSE PyGILState_Release(*pygilstate); #endif for (lnum = RangeStart; lnum <= RangeEnd; ++lnum) { PyObject *line; PyObject *linenr; PyObject *ret; #ifdef PY_CAN_RECURSE *pygilstate = PyGILState_Ensure(); #endif // Check the line number, the command my have deleted lines. if (lnum > curbuf->b_ml.ml_line_count || !(line = GetBufferLine(curbuf, lnum))) goto err; if (!(linenr = PyInt_FromLong((long) lnum))) { Py_DECREF(line); goto err; } ret = PyObject_CallFunctionObjArgs(pyfunc, line, linenr, NULL); Py_DECREF(line); Py_DECREF(linenr); if (!ret) goto err; // Check that the command didn't switch to another buffer. if (curbuf != was_curbuf) { Py_XDECREF(ret); goto err; } if (ret != Py_None) if (SetBufferLine(curbuf, lnum, ret, NULL) == FAIL) { Py_XDECREF(ret); goto err; } Py_XDECREF(ret); PythonIO_Flush(); #ifdef PY_CAN_RECURSE PyGILState_Release(*pygilstate); #endif } goto out; err: #ifdef PY_CAN_RECURSE *pygilstate = PyGILState_Ensure(); #endif PyErr_PrintEx(0); PythonIO_Flush(); status = 1; out: #ifdef PY_CAN_RECURSE if (!status) *pygilstate = PyGILState_Ensure(); #endif Py_DECREF(pyfunc); PyObject_SetAttrString(pymain, DOPY_FUNC, NULL); if (status) return; check_cursor(); update_curbuf(NOT_VALID); } static void run_eval(const char *cmd, typval_T *rettv #ifdef PY_CAN_RECURSE , PyGILState_STATE *pygilstate UNUSED #endif ) { PyObject *run_ret; run_ret = PyRun_String((char *)cmd, Py_eval_input, globals, globals); if (run_ret == NULL) { if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SystemExit)) { semsg(_(e_py_systemexit), "python"); PyErr_Clear(); } else { if (PyErr_Occurred() && !msg_silent) PyErr_PrintEx(0); emsg(_("E858: Eval did not return a valid python object")); } } else { if (ConvertFromPyObject(run_ret, rettv) == -1) emsg(_("E859: Failed to convert returned python object to vim value")); Py_DECREF(run_ret); } PyErr_Clear(); } static int set_ref_in_py(const int copyID) { pylinkedlist_T *cur; list_T *ll; int i; int abort = FALSE; FunctionObject *func; if (lastdict != NULL) { for (cur = lastdict ; !abort && cur != NULL ; cur = cur->pll_prev) abort = set_ref_in_dict(((DictionaryObject *)(cur->pll_obj))->dict, copyID); } if (lastlist != NULL) { for (cur = lastlist ; !abort && cur != NULL ; cur = cur->pll_prev) { ll = ((ListObject *) (cur->pll_obj))->list; abort = set_ref_in_list(ll, copyID); } } if (lastfunc != NULL) { for (cur = lastfunc ; !abort && cur != NULL ; cur = cur->pll_prev) { func = (FunctionObject *) cur->pll_obj; abort = set_ref_in_dict(func->self, copyID); if (func->argc) for (i = 0; !abort && i < func->argc; ++i) abort = abort || set_ref_in_item(&func->argv[i], copyID, NULL, NULL); } } return abort; } static int set_string_copy(char_u *str, typval_T *tv) { tv->vval.v_string = vim_strsave(str); if (tv->vval.v_string == NULL) { PyErr_NoMemory(); return -1; } return 0; } static int pydict_to_tv(PyObject *obj, typval_T *tv, PyObject *lookup_dict) { dict_T *dict; char_u *key; dictitem_T *di; PyObject *keyObject; PyObject *valObject; Py_ssize_t iter = 0; if (!(dict = py_dict_alloc())) return -1; tv->v_type = VAR_DICT; tv->vval.v_dict = dict; while (PyDict_Next(obj, &iter, &keyObject, &valObject)) { PyObject *todecref = NULL; if (keyObject == NULL || valObject == NULL) { dict_unref(dict); return -1; } if (!(key = StringToChars(keyObject, &todecref))) { dict_unref(dict); return -1; } if (*key == NUL) { dict_unref(dict); Py_XDECREF(todecref); RAISE_NO_EMPTY_KEYS; return -1; } di = dictitem_alloc(key); Py_XDECREF(todecref); if (di == NULL) { PyErr_NoMemory(); dict_unref(dict); return -1; } if (_ConvertFromPyObject(valObject, &di->di_tv, lookup_dict) == -1) { vim_free(di); dict_unref(dict); return -1; } if (dict_add(dict, di) == FAIL) { RAISE_KEY_ADD_FAIL(di->di_key); clear_tv(&di->di_tv); vim_free(di); dict_unref(dict); return -1; } } --dict->dv_refcount; return 0; } static int pymap_to_tv(PyObject *obj, typval_T *tv, PyObject *lookup_dict) { dict_T *dict; char_u *key; dictitem_T *di; PyObject *list; PyObject *iterator; PyObject *keyObject; PyObject *valObject; if (!(dict = py_dict_alloc())) return -1; tv->v_type = VAR_DICT; tv->vval.v_dict = dict; if (!(list = PyMapping_Keys(obj))) { dict_unref(dict); return -1; } if (!(iterator = PyObject_GetIter(list))) { dict_unref(dict); Py_DECREF(list); return -1; } Py_DECREF(list); while ((keyObject = PyIter_Next(iterator))) { PyObject *todecref; if (!(key = StringToChars(keyObject, &todecref))) { Py_DECREF(keyObject); Py_DECREF(iterator); dict_unref(dict); return -1; } if (*key == NUL) { Py_DECREF(keyObject); Py_DECREF(iterator); Py_XDECREF(todecref); dict_unref(dict); RAISE_NO_EMPTY_KEYS; return -1; } if (!(valObject = PyObject_GetItem(obj, keyObject))) { Py_DECREF(keyObject); Py_DECREF(iterator); Py_XDECREF(todecref); dict_unref(dict); return -1; } di = dictitem_alloc(key); Py_DECREF(keyObject); Py_XDECREF(todecref); if (di == NULL) { Py_DECREF(iterator); Py_DECREF(valObject); dict_unref(dict); PyErr_NoMemory(); return -1; } if (_ConvertFromPyObject(valObject, &di->di_tv, lookup_dict) == -1) { Py_DECREF(iterator); Py_DECREF(valObject); vim_free(di); dict_unref(dict); return -1; } Py_DECREF(valObject); if (dict_add(dict, di) == FAIL) { RAISE_KEY_ADD_FAIL(di->di_key); Py_DECREF(iterator); dictitem_free(di); dict_unref(dict); return -1; } } Py_DECREF(iterator); --dict->dv_refcount; return 0; } static int pyseq_to_tv(PyObject *obj, typval_T *tv, PyObject *lookup_dict) { list_T *l; if (!(l = py_list_alloc())) return -1; tv->v_type = VAR_LIST; tv->vval.v_list = l; if (list_py_concat(l, obj, lookup_dict) == -1) { list_unref(l); return -1; } --l->lv_refcount; return 0; } typedef int (*pytotvfunc)(PyObject *, typval_T *, PyObject *); static int convert_dl(PyObject *obj, typval_T *tv, pytotvfunc py_to_tv, PyObject *lookup_dict) { PyObject *capsule; char hexBuf[sizeof(void *) * 2 + 3]; sprintf(hexBuf, "%p", (void *)obj); #ifdef PY_USE_CAPSULE capsule = PyDict_GetItemString(lookup_dict, hexBuf); #else capsule = (PyObject *)PyDict_GetItemString(lookup_dict, hexBuf); #endif if (capsule == NULL) { #ifdef PY_USE_CAPSULE capsule = PyCapsule_New(tv, NULL, NULL); #else capsule = PyCObject_FromVoidPtr(tv, NULL); #endif if (PyDict_SetItemString(lookup_dict, hexBuf, capsule)) { Py_DECREF(capsule); tv->v_type = VAR_UNKNOWN; return -1; } Py_DECREF(capsule); if (py_to_tv(obj, tv, lookup_dict) == -1) { tv->v_type = VAR_UNKNOWN; return -1; } // As we are not using copy_tv which increments reference count we must // do it ourself. if (tv->v_type == VAR_DICT) ++tv->vval.v_dict->dv_refcount; else if (tv->v_type == VAR_LIST) ++tv->vval.v_list->lv_refcount; } else { typval_T *v; #ifdef PY_USE_CAPSULE v = PyCapsule_GetPointer(capsule, NULL); #else v = PyCObject_AsVoidPtr(capsule); #endif copy_tv(v, tv); } return 0; } static int ConvertFromPyMapping(PyObject *obj, typval_T *tv) { PyObject *lookup_dict; int ret; if (!(lookup_dict = PyDict_New())) return -1; if (PyType_IsSubtype(obj->ob_type, &DictionaryType)) { tv->v_type = VAR_DICT; tv->vval.v_dict = (((DictionaryObject *)(obj))->dict); ++tv->vval.v_dict->dv_refcount; ret = 0; } else if (PyDict_Check(obj)) ret = convert_dl(obj, tv, pydict_to_tv, lookup_dict); else if (PyMapping_Check(obj)) ret = convert_dl(obj, tv, pymap_to_tv, lookup_dict); else { PyErr_FORMAT(PyExc_TypeError, N_("unable to convert %s to vim dictionary"), Py_TYPE_NAME(obj)); ret = -1; } Py_DECREF(lookup_dict); return ret; } static int ConvertFromPySequence(PyObject *obj, typval_T *tv) { PyObject *lookup_dict; int ret; if (!(lookup_dict = PyDict_New())) return -1; if (PyType_IsSubtype(obj->ob_type, &ListType)) { tv->v_type = VAR_LIST; tv->vval.v_list = (((ListObject *)(obj))->list); ++tv->vval.v_list->lv_refcount; ret = 0; } else if (PyIter_Check(obj) || PySequence_Check(obj)) ret = convert_dl(obj, tv, pyseq_to_tv, lookup_dict); else { PyErr_FORMAT(PyExc_TypeError, N_("unable to convert %s to vim list"), Py_TYPE_NAME(obj)); ret = -1; } Py_DECREF(lookup_dict); return ret; } static int ConvertFromPyObject(PyObject *obj, typval_T *tv) { PyObject *lookup_dict; int ret; if (!(lookup_dict = PyDict_New())) return -1; ret = _ConvertFromPyObject(obj, tv, lookup_dict); Py_DECREF(lookup_dict); return ret; } static int _ConvertFromPyObject(PyObject *obj, typval_T *tv, PyObject *lookup_dict) { if (PyType_IsSubtype(obj->ob_type, &DictionaryType)) { tv->v_type = VAR_DICT; tv->vval.v_dict = (((DictionaryObject *)(obj))->dict); ++tv->vval.v_dict->dv_refcount; } else if (PyType_IsSubtype(obj->ob_type, &ListType)) { tv->v_type = VAR_LIST; tv->vval.v_list = (((ListObject *)(obj))->list); ++tv->vval.v_list->lv_refcount; } else if (PyType_IsSubtype(obj->ob_type, &FunctionType)) { FunctionObject *func = (FunctionObject *) obj; if (func->self != NULL || func->argv != NULL) { partial_T *pt = ALLOC_CLEAR_ONE(partial_T); set_partial(func, pt, TRUE); tv->vval.v_partial = pt; tv->v_type = VAR_PARTIAL; } else { if (set_string_copy(func->name, tv) == -1) return -1; tv->v_type = VAR_FUNC; } func_ref(func->name); } else if (PyBytes_Check(obj)) { char_u *str; if (PyBytes_AsStringAndSize(obj, (char **) &str, NULL) == -1) return -1; if (str == NULL) return -1; if (set_string_copy(str, tv) == -1) return -1; tv->v_type = VAR_STRING; } else if (PyUnicode_Check(obj)) { PyObject *bytes; char_u *str; bytes = PyUnicode_AsEncodedString(obj, ENC_OPT, NULL); if (bytes == NULL) return -1; if(PyBytes_AsStringAndSize(bytes, (char **) &str, NULL) == -1) return -1; if (str == NULL) return -1; if (set_string_copy(str, tv)) { Py_XDECREF(bytes); return -1; } Py_XDECREF(bytes); tv->v_type = VAR_STRING; } #if PY_MAJOR_VERSION < 3 else if (PyInt_Check(obj)) { tv->v_type = VAR_NUMBER; tv->vval.v_number = (varnumber_T) PyInt_AsLong(obj); if (PyErr_Occurred()) return -1; } #endif else if (PyLong_Check(obj)) { tv->v_type = VAR_NUMBER; tv->vval.v_number = (varnumber_T) PyLong_AsLong(obj); if (PyErr_Occurred()) return -1; } else if (PyDict_Check(obj)) return convert_dl(obj, tv, pydict_to_tv, lookup_dict); #ifdef FEAT_FLOAT else if (PyFloat_Check(obj)) { tv->v_type = VAR_FLOAT; tv->vval.v_float = (float_T) PyFloat_AsDouble(obj); } #endif else if (PyObject_HasAttrString(obj, "keys")) return convert_dl(obj, tv, pymap_to_tv, lookup_dict); // PyObject_GetIter can create built-in iterator for any sequence object else if (PyIter_Check(obj) || PySequence_Check(obj)) return convert_dl(obj, tv, pyseq_to_tv, lookup_dict); else if (PyMapping_Check(obj)) return convert_dl(obj, tv, pymap_to_tv, lookup_dict); else if (PyNumber_Check(obj)) { PyObject *num; if (!(num = PyNumber_Long(obj))) return -1; tv->v_type = VAR_NUMBER; tv->vval.v_number = (varnumber_T) PyLong_AsLong(num); Py_DECREF(num); } else if (obj == Py_None) { tv->v_type = VAR_SPECIAL; tv->vval.v_number = VVAL_NONE; } else { PyErr_FORMAT(PyExc_TypeError, N_("unable to convert %s to vim structure"), Py_TYPE_NAME(obj)); return -1; } return 0; } static PyObject * ConvertToPyObject(typval_T *tv) { typval_T *argv; int i; if (tv == NULL) { PyErr_SET_VIM(N_("internal error: NULL reference passed")); return NULL; } switch (tv->v_type) { case VAR_STRING: return PyBytes_FromString(tv->vval.v_string == NULL ? "" : (char *)tv->vval.v_string); case VAR_NUMBER: return PyLong_FromLong((long) tv->vval.v_number); case VAR_FLOAT: #ifdef FEAT_FLOAT return PyFloat_FromDouble((double) tv->vval.v_float); #endif case VAR_LIST: return NEW_LIST(tv->vval.v_list); case VAR_DICT: return NEW_DICTIONARY(tv->vval.v_dict); case VAR_FUNC: return NEW_FUNCTION(tv->vval.v_string == NULL ? (char_u *)"" : tv->vval.v_string, 0, NULL, NULL, TRUE); case VAR_PARTIAL: if (tv->vval.v_partial->pt_argc) { argv = PyMem_New(typval_T, (size_t)tv->vval.v_partial->pt_argc); for (i = 0; i < tv->vval.v_partial->pt_argc; i++) copy_tv(&tv->vval.v_partial->pt_argv[i], &argv[i]); } else argv = NULL; if (tv->vval.v_partial->pt_dict != NULL) tv->vval.v_partial->pt_dict->dv_refcount++; return NEW_FUNCTION(tv->vval.v_partial == NULL ? (char_u *)"" : partial_name(tv->vval.v_partial), tv->vval.v_partial->pt_argc, argv, tv->vval.v_partial->pt_dict, tv->vval.v_partial->pt_auto); case VAR_BLOB: return PyBytes_FromStringAndSize( (char*) tv->vval.v_blob->bv_ga.ga_data, (Py_ssize_t) tv->vval.v_blob->bv_ga.ga_len); case VAR_UNKNOWN: case VAR_VOID: case VAR_CHANNEL: case VAR_JOB: Py_INCREF(Py_None); return Py_None; case VAR_BOOL: case VAR_SPECIAL: switch (tv->vval.v_number) { case VVAL_FALSE: return AlwaysFalse(NULL); case VVAL_TRUE: return AlwaysTrue(NULL); case VVAL_NONE: case VVAL_NULL: return AlwaysNone(NULL); } PyErr_SET_VIM(N_("internal error: invalid value type")); return NULL; } return NULL; } typedef struct { PyObject_HEAD } CurrentObject; static PyTypeObject CurrentType; static void init_structs(void) { vim_memset(&OutputType, 0, sizeof(OutputType)); OutputType.tp_name = "vim.message"; OutputType.tp_basicsize = sizeof(OutputObject); OutputType.tp_flags = Py_TPFLAGS_DEFAULT; OutputType.tp_doc = "vim message object"; OutputType.tp_methods = OutputMethods; #if PY_MAJOR_VERSION >= 3 OutputType.tp_getattro = (getattrofunc)OutputGetattro; OutputType.tp_setattro = (setattrofunc)OutputSetattro; OutputType.tp_alloc = call_PyType_GenericAlloc; OutputType.tp_new = call_PyType_GenericNew; OutputType.tp_free = call_PyObject_Free; OutputType.tp_base = &PyStdPrinter_Type; #else OutputType.tp_getattr = (getattrfunc)OutputGetattr; OutputType.tp_setattr = (setattrfunc)OutputSetattr; // Disabled, because this causes a crash in test86 // OutputType.tp_base = &PyFile_Type; #endif vim_memset(&IterType, 0, sizeof(IterType)); IterType.tp_name = "vim.iter"; IterType.tp_basicsize = sizeof(IterObject); IterType.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC; IterType.tp_doc = "generic iterator object"; IterType.tp_iter = (getiterfunc)IterIter; IterType.tp_iternext = (iternextfunc)IterNext; IterType.tp_dealloc = (destructor)IterDestructor; IterType.tp_traverse = (traverseproc)IterTraverse; IterType.tp_clear = (inquiry)IterClear; vim_memset(&BufferType, 0, sizeof(BufferType)); BufferType.tp_name = "vim.buffer"; BufferType.tp_basicsize = sizeof(BufferType); BufferType.tp_dealloc = (destructor)BufferDestructor; BufferType.tp_repr = (reprfunc)BufferRepr; BufferType.tp_as_sequence = &BufferAsSeq; BufferType.tp_as_mapping = &BufferAsMapping; BufferType.tp_flags = Py_TPFLAGS_DEFAULT; BufferType.tp_doc = "vim buffer object"; BufferType.tp_methods = BufferMethods; #if PY_MAJOR_VERSION >= 3 BufferType.tp_getattro = (getattrofunc)BufferGetattro; BufferType.tp_setattro = (setattrofunc)BufferSetattro; BufferType.tp_alloc = call_PyType_GenericAlloc; BufferType.tp_new = call_PyType_GenericNew; BufferType.tp_free = call_PyObject_Free; #else BufferType.tp_getattr = (getattrfunc)BufferGetattr; BufferType.tp_setattr = (setattrfunc)BufferSetattr; #endif vim_memset(&WindowType, 0, sizeof(WindowType)); WindowType.tp_name = "vim.window"; WindowType.tp_basicsize = sizeof(WindowObject); WindowType.tp_dealloc = (destructor)WindowDestructor; WindowType.tp_repr = (reprfunc)WindowRepr; WindowType.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC; WindowType.tp_doc = "vim Window object"; WindowType.tp_methods = WindowMethods; WindowType.tp_traverse = (traverseproc)WindowTraverse; WindowType.tp_clear = (inquiry)WindowClear; #if PY_MAJOR_VERSION >= 3 WindowType.tp_getattro = (getattrofunc)WindowGetattro; WindowType.tp_setattro = (setattrofunc)WindowSetattro; WindowType.tp_alloc = call_PyType_GenericAlloc; WindowType.tp_new = call_PyType_GenericNew; WindowType.tp_free = call_PyObject_Free; #else WindowType.tp_getattr = (getattrfunc)WindowGetattr; WindowType.tp_setattr = (setattrfunc)WindowSetattr; #endif vim_memset(&TabPageType, 0, sizeof(TabPageType)); TabPageType.tp_name = "vim.tabpage"; TabPageType.tp_basicsize = sizeof(TabPageObject); TabPageType.tp_dealloc = (destructor)TabPageDestructor; TabPageType.tp_repr = (reprfunc)TabPageRepr; TabPageType.tp_flags = Py_TPFLAGS_DEFAULT; TabPageType.tp_doc = "vim tab page object"; TabPageType.tp_methods = TabPageMethods; #if PY_MAJOR_VERSION >= 3 TabPageType.tp_getattro = (getattrofunc)TabPageGetattro; TabPageType.tp_alloc = call_PyType_GenericAlloc; TabPageType.tp_new = call_PyType_GenericNew; TabPageType.tp_free = call_PyObject_Free; #else TabPageType.tp_getattr = (getattrfunc)TabPageGetattr; #endif vim_memset(&BufMapType, 0, sizeof(BufMapType)); BufMapType.tp_name = "vim.bufferlist"; BufMapType.tp_basicsize = sizeof(BufMapObject); BufMapType.tp_as_mapping = &BufMapAsMapping; BufMapType.tp_flags = Py_TPFLAGS_DEFAULT; BufMapType.tp_iter = BufMapIter; BufferType.tp_doc = "vim buffer list"; vim_memset(&WinListType, 0, sizeof(WinListType)); WinListType.tp_name = "vim.windowlist"; WinListType.tp_basicsize = sizeof(WinListType); WinListType.tp_as_sequence = &WinListAsSeq; WinListType.tp_flags = Py_TPFLAGS_DEFAULT; WinListType.tp_doc = "vim window list"; WinListType.tp_dealloc = (destructor)WinListDestructor; vim_memset(&TabListType, 0, sizeof(TabListType)); TabListType.tp_name = "vim.tabpagelist"; TabListType.tp_basicsize = sizeof(TabListType); TabListType.tp_as_sequence = &TabListAsSeq; TabListType.tp_flags = Py_TPFLAGS_DEFAULT; TabListType.tp_doc = "vim tab page list"; vim_memset(&RangeType, 0, sizeof(RangeType)); RangeType.tp_name = "vim.range"; RangeType.tp_basicsize = sizeof(RangeObject); RangeType.tp_dealloc = (destructor)RangeDestructor; RangeType.tp_repr = (reprfunc)RangeRepr; RangeType.tp_as_sequence = &RangeAsSeq; RangeType.tp_as_mapping = &RangeAsMapping; RangeType.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC; RangeType.tp_doc = "vim Range object"; RangeType.tp_methods = RangeMethods; RangeType.tp_traverse = (traverseproc)RangeTraverse; RangeType.tp_clear = (inquiry)RangeClear; #if PY_MAJOR_VERSION >= 3 RangeType.tp_getattro = (getattrofunc)RangeGetattro; RangeType.tp_alloc = call_PyType_GenericAlloc; RangeType.tp_new = call_PyType_GenericNew; RangeType.tp_free = call_PyObject_Free; #else RangeType.tp_getattr = (getattrfunc)RangeGetattr; #endif vim_memset(&CurrentType, 0, sizeof(CurrentType)); CurrentType.tp_name = "vim.currentdata"; CurrentType.tp_basicsize = sizeof(CurrentObject); CurrentType.tp_flags = Py_TPFLAGS_DEFAULT; CurrentType.tp_doc = "vim current object"; CurrentType.tp_methods = CurrentMethods; #if PY_MAJOR_VERSION >= 3 CurrentType.tp_getattro = (getattrofunc)CurrentGetattro; CurrentType.tp_setattro = (setattrofunc)CurrentSetattro; #else CurrentType.tp_getattr = (getattrfunc)CurrentGetattr; CurrentType.tp_setattr = (setattrfunc)CurrentSetattr; #endif vim_memset(&DictionaryType, 0, sizeof(DictionaryType)); DictionaryType.tp_name = "vim.dictionary"; DictionaryType.tp_basicsize = sizeof(DictionaryObject); DictionaryType.tp_dealloc = (destructor)DictionaryDestructor; DictionaryType.tp_as_sequence = &DictionaryAsSeq; DictionaryType.tp_as_mapping = &DictionaryAsMapping; DictionaryType.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE; DictionaryType.tp_doc = "dictionary pushing modifications to vim structure"; DictionaryType.tp_methods = DictionaryMethods; DictionaryType.tp_iter = (getiterfunc)DictionaryIter; DictionaryType.tp_new = (newfunc)DictionaryConstructor; DictionaryType.tp_alloc = (allocfunc)PyType_GenericAlloc; #if PY_MAJOR_VERSION >= 3 DictionaryType.tp_getattro = (getattrofunc)DictionaryGetattro; DictionaryType.tp_setattro = (setattrofunc)DictionarySetattro; #else DictionaryType.tp_getattr = (getattrfunc)DictionaryGetattr; DictionaryType.tp_setattr = (setattrfunc)DictionarySetattr; #endif vim_memset(&ListType, 0, sizeof(ListType)); ListType.tp_name = "vim.list"; ListType.tp_dealloc = (destructor)ListDestructor; ListType.tp_basicsize = sizeof(ListObject); ListType.tp_as_sequence = &ListAsSeq; ListType.tp_as_mapping = &ListAsMapping; ListType.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE; ListType.tp_doc = "list pushing modifications to vim structure"; ListType.tp_methods = ListMethods; ListType.tp_iter = (getiterfunc)ListIter; ListType.tp_new = (newfunc)ListConstructor; ListType.tp_alloc = (allocfunc)PyType_GenericAlloc; #if PY_MAJOR_VERSION >= 3 ListType.tp_getattro = (getattrofunc)ListGetattro; ListType.tp_setattro = (setattrofunc)ListSetattro; #else ListType.tp_getattr = (getattrfunc)ListGetattr; ListType.tp_setattr = (setattrfunc)ListSetattr; #endif vim_memset(&FunctionType, 0, sizeof(FunctionType)); FunctionType.tp_name = "vim.function"; FunctionType.tp_basicsize = sizeof(FunctionObject); FunctionType.tp_dealloc = (destructor)FunctionDestructor; FunctionType.tp_call = (ternaryfunc)FunctionCall; FunctionType.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE; FunctionType.tp_doc = "object that calls vim function"; FunctionType.tp_methods = FunctionMethods; FunctionType.tp_repr = (reprfunc)FunctionRepr; FunctionType.tp_new = (newfunc)FunctionConstructor; FunctionType.tp_alloc = (allocfunc)PyType_GenericAlloc; #if PY_MAJOR_VERSION >= 3 FunctionType.tp_getattro = (getattrofunc)FunctionGetattro; #else FunctionType.tp_getattr = (getattrfunc)FunctionGetattr; #endif vim_memset(&OptionsType, 0, sizeof(OptionsType)); OptionsType.tp_name = "vim.options"; OptionsType.tp_basicsize = sizeof(OptionsObject); OptionsType.tp_as_sequence = &OptionsAsSeq; OptionsType.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC; OptionsType.tp_doc = "object for manipulating options"; OptionsType.tp_iter = (getiterfunc)OptionsIter; OptionsType.tp_as_mapping = &OptionsAsMapping; OptionsType.tp_dealloc = (destructor)OptionsDestructor; OptionsType.tp_traverse = (traverseproc)OptionsTraverse; OptionsType.tp_clear = (inquiry)OptionsClear; #if PY_VERSION_HEX < 0x030700f0 vim_memset(&LoaderType, 0, sizeof(LoaderType)); LoaderType.tp_name = "vim.Loader"; LoaderType.tp_basicsize = sizeof(LoaderObject); LoaderType.tp_flags = Py_TPFLAGS_DEFAULT; LoaderType.tp_doc = "vim message object"; LoaderType.tp_methods = LoaderMethods; LoaderType.tp_dealloc = (destructor)LoaderDestructor; #endif #if PY_MAJOR_VERSION >= 3 vim_memset(&vimmodule, 0, sizeof(vimmodule)); vimmodule.m_name = "vim"; vimmodule.m_doc = "Vim Python interface\n"; vimmodule.m_size = -1; vimmodule.m_methods = VimMethods; #endif } #define PYTYPE_READY(type) \ if (PyType_Ready(&type)) \ return -1; static int init_types(void) { PYTYPE_READY(IterType); PYTYPE_READY(BufferType); PYTYPE_READY(RangeType); PYTYPE_READY(WindowType); PYTYPE_READY(TabPageType); PYTYPE_READY(BufMapType); PYTYPE_READY(WinListType); PYTYPE_READY(TabListType); PYTYPE_READY(CurrentType); PYTYPE_READY(DictionaryType); PYTYPE_READY(ListType); PYTYPE_READY(FunctionType); PYTYPE_READY(OptionsType); PYTYPE_READY(OutputType); #if PY_VERSION_HEX < 0x030700f0 PYTYPE_READY(LoaderType); #endif return 0; } static int init_sys_path(void) { PyObject *path; PyObject *path_hook; PyObject *path_hooks; if (!(path_hook = PyObject_GetAttrString(vim_module, "path_hook"))) return -1; if (!(path_hooks = PySys_GetObject("path_hooks"))) { PyErr_Clear(); path_hooks = PyList_New(1); PyList_SET_ITEM(path_hooks, 0, path_hook); if (PySys_SetObject("path_hooks", path_hooks)) { Py_DECREF(path_hooks); return -1; } Py_DECREF(path_hooks); } else if (PyList_Check(path_hooks)) { if (PyList_Append(path_hooks, path_hook)) { Py_DECREF(path_hook); return -1; } Py_DECREF(path_hook); } else { VimTryStart(); emsg(_("Failed to set path hook: sys.path_hooks is not a list\n" "You should now do the following:\n" "- append vim.path_hook to sys.path_hooks\n" "- append vim.VIM_SPECIAL_PATH to sys.path\n")); VimTryEnd(); // Discard the error Py_DECREF(path_hook); return 0; } if (!(path = PySys_GetObject("path"))) { PyErr_Clear(); path = PyList_New(1); Py_INCREF(vim_special_path_object); PyList_SET_ITEM(path, 0, vim_special_path_object); if (PySys_SetObject("path", path)) { Py_DECREF(path); return -1; } Py_DECREF(path); } else if (PyList_Check(path)) { if (PyList_Append(path, vim_special_path_object)) return -1; } else { VimTryStart(); emsg(_("Failed to set path: sys.path is not a list\n" "You should now append vim.VIM_SPECIAL_PATH to sys.path")); VimTryEnd(); // Discard the error } return 0; } static BufMapObject TheBufferMap = { PyObject_HEAD_INIT(&BufMapType) }; static WinListObject TheWindowList = { PyObject_HEAD_INIT(&WinListType) NULL }; static CurrentObject TheCurrent = { PyObject_HEAD_INIT(&CurrentType) }; static TabListObject TheTabPageList = { PyObject_HEAD_INIT(&TabListType) }; static struct numeric_constant { char *name; int val; } numeric_constants[] = { {"VAR_LOCKED", VAR_LOCKED}, {"VAR_FIXED", VAR_FIXED}, {"VAR_SCOPE", VAR_SCOPE}, {"VAR_DEF_SCOPE", VAR_DEF_SCOPE}, }; static struct object_constant { char *name; PyObject *valObject; } object_constants[] = { {"buffers", (PyObject *)(void *)&TheBufferMap}, {"windows", (PyObject *)(void *)&TheWindowList}, {"tabpages", (PyObject *)(void *)&TheTabPageList}, {"current", (PyObject *)(void *)&TheCurrent}, {"Buffer", (PyObject *)&BufferType}, {"Range", (PyObject *)&RangeType}, {"Window", (PyObject *)&WindowType}, {"TabPage", (PyObject *)&TabPageType}, {"Dictionary", (PyObject *)&DictionaryType}, {"List", (PyObject *)&ListType}, {"Function", (PyObject *)&FunctionType}, {"Options", (PyObject *)&OptionsType}, #if PY_VERSION_HEX < 0x030700f0 {"_Loader", (PyObject *)&LoaderType}, #endif }; #define ADD_OBJECT(m, name, obj) \ if (PyModule_AddObject(m, name, obj)) \ return -1; #define ADD_CHECKED_OBJECT(m, name, obj) \ { \ PyObject *valObject = obj; \ if (!valObject) \ return -1; \ ADD_OBJECT(m, name, valObject); \ } static int populate_module(PyObject *m) { int i; PyObject *other_module; PyObject *attr; PyObject *imp; #if PY_VERSION_HEX >= 0x030700f0 PyObject *dict; PyObject *cls; #endif for (i = 0; i < (int)(sizeof(numeric_constants) / sizeof(struct numeric_constant)); ++i) ADD_CHECKED_OBJECT(m, numeric_constants[i].name, PyInt_FromLong(numeric_constants[i].val)); for (i = 0; i < (int)(sizeof(object_constants) / sizeof(struct object_constant)); ++i) { PyObject *valObject; valObject = object_constants[i].valObject; Py_INCREF(valObject); ADD_OBJECT(m, object_constants[i].name, valObject); } if (!(VimError = PyErr_NewException("vim.error", NULL, NULL))) return -1; ADD_OBJECT(m, "error", VimError); ADD_CHECKED_OBJECT(m, "vars", NEW_DICTIONARY(get_globvar_dict())); ADD_CHECKED_OBJECT(m, "vvars", NEW_DICTIONARY(get_vimvar_dict())); ADD_CHECKED_OBJECT(m, "options", OptionsNew(SREQ_GLOBAL, NULL, dummy_check, NULL)); if (!(other_module = PyImport_ImportModule("os"))) return -1; ADD_OBJECT(m, "os", other_module); #if PY_MAJOR_VERSION >= 3 if (!(py_getcwd = PyObject_GetAttrString(other_module, "getcwd"))) return -1; #else if (!(py_getcwd = PyObject_GetAttrString(other_module, "getcwdu"))) return -1; #endif ADD_OBJECT(m, "_getcwd", py_getcwd) if (!(py_chdir = PyObject_GetAttrString(other_module, "chdir"))) return -1; ADD_OBJECT(m, "_chdir", py_chdir); if (!(attr = PyObject_GetAttrString(m, "chdir"))) return -1; if (PyObject_SetAttrString(other_module, "chdir", attr)) { Py_DECREF(attr); return -1; } Py_DECREF(attr); if ((py_fchdir = PyObject_GetAttrString(other_module, "fchdir"))) { ADD_OBJECT(m, "_fchdir", py_fchdir); if (!(attr = PyObject_GetAttrString(m, "fchdir"))) return -1; if (PyObject_SetAttrString(other_module, "fchdir", attr)) { Py_DECREF(attr); return -1; } Py_DECREF(attr); } else PyErr_Clear(); if (!(vim_special_path_object = PyString_FromString(vim_special_path))) return -1; ADD_OBJECT(m, "VIM_SPECIAL_PATH", vim_special_path_object); #if PY_VERSION_HEX >= 0x030700f0 if (!(imp = PyImport_ImportModule("importlib.machinery"))) return -1; dict = PyModule_GetDict(imp); if (!(cls = PyDict_GetItemString(dict, "PathFinder"))) { Py_DECREF(imp); return -1; } if (!(py_find_spec = PyObject_GetAttrString(cls, "find_spec"))) { Py_DECREF(imp); return -1; } if ((py_find_module = PyObject_GetAttrString(cls, "find_module"))) { // find_module() is deprecated, this may stop working in some later // version. ADD_OBJECT(m, "_find_module", py_find_module); } Py_DECREF(imp); ADD_OBJECT(m, "_find_spec", py_find_spec); #else if (!(imp = PyImport_ImportModule("imp"))) return -1; if (!(py_find_module = PyObject_GetAttrString(imp, "find_module"))) { Py_DECREF(imp); return -1; } if (!(py_load_module = PyObject_GetAttrString(imp, "load_module"))) { Py_DECREF(py_find_module); Py_DECREF(imp); return -1; } Py_DECREF(imp); ADD_OBJECT(m, "_find_module", py_find_module); ADD_OBJECT(m, "_load_module", py_load_module); #endif return 0; }