mirror of https://github.com/vim/vim.git
6958 lines
148 KiB
C
6958 lines
148 KiB
C
/* 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);
|
|
#ifdef FEAT_FLOAT
|
|
case VAR_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;
|
|
}
|