vim: src/if_python3.c comparison

comparison src/if_python3.c @ 2399:76f0c4918f5c vim73

Move some common code from if_python.c and if_python3.c to if_py_both.h.

author	Bram Moolenaar <bram@vim.org>
date	Sat, 24 Jul 2010 23:51:45 +0200
parents	aeea25941392
children	eb4718cb2a76

comparison

equal deleted inserted replaced

-:0c8219a26bc9
+:76f0c4918f5c
 #endif
 #undef main /* Defined in python.h - aargh */
 #undef HAVE_FCNTL_H /* Clash with os_win32.h */
 static void init_structs(void);
+#define PyInt Py_ssize_t
 #if defined(DYNAMIC_PYTHON3)
 #ifndef WIN3264
 #include <dlfcn.h>
 };
 /*
 * Free python.dll
 */
-static void end_dynamic_python3(void)
+static void
+end_dynamic_python3(void)
 {
 if (hinstPy3 != 0)
 {
 	close_dll(hinstPy3);
 	hinstPy3 = 0;
 /*
 * Load library and get all pointers.
 * Parameter 'libname' provides name of DLL.
 * Return OK or FAIL.
 */
-static int py3_runtime_link_init(char *libname, int verbose)
+static int
+py3_runtime_link_init(char *libname, int verbose)
 {
 int i;
 void *ucs_from_string, *ucs_from_string_and_size;
 #if defined(UNIX) && defined(FEAT_PYTHON)
 /*
 * If python is enabled (there is installed python on Windows system) return
 * TRUE, else FALSE.
 */
-int python3_enabled(int verbose)
+int
+python3_enabled(int verbose)
 {
 return py3_runtime_link_init(DYNAMIC_PYTHON3_DLL, verbose) == OK;
 }
 /* Load the standard Python exceptions - don't import the symbols from the
 * DLL, as this can cause errors (importing data symbols is not reliable).
 */
 static void get_py3_exceptions __ARGS((void));
-static void get_py3_exceptions()
+static void
+get_py3_exceptions()
 {
 PyObject *exmod = PyImport_ImportModule("builtins");
 PyObject *exdict = PyModule_GetDict(exmod);
 p3imp_PyExc_AttributeError = PyDict_GetItemString(exdict, "AttributeError");
 p3imp_PyExc_IndexError = PyDict_GetItemString(exdict, "IndexError");
 Py_XINCREF(p3imp_PyExc_ValueError);
 Py_XDECREF(exmod);
 }
 #endif /* DYNAMIC_PYTHON3 */
-static void call_PyObject_Free(void *p)
+/*
+* Include the code shared with if_python.c
+*/
+#include "if_py_both.h"
+static void
+call_PyObject_Free(void *p)
 {
 #ifdef Py_DEBUG
 _PyObject_DebugFree(p);
 #else
 PyObject_Free(p);
 #endif
 }
-static PyObject* call_PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
+static PyObject *
+call_PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
 return PyType_GenericNew(type,args,kwds);
 }
-static PyObject* call_PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
+static PyObject *
+call_PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
 {
 return PyType_GenericAlloc(type,nitems);
 }
 /******************************************************
 static PyObject *GetBufferLineList(buf_T *buf, Py_ssize_t lo, Py_ssize_t hi);
 static PyObject *LineToString(const char *);
 static char *StringToLine(PyObject *);
-static int VimErrorCheck(void);
 #define PyErr_SetVim(str) PyErr_SetString(VimError, str)
 /******************************************************
 * 1. Python interpreter main program.
 */
 static int py3initialised = 0;
 static PyGILState_STATE pygilstate = PyGILState_UNLOCKED;
-/*
+void
-* obtain a lock on the Vim data structures
+python3_end()
-*/
-static void Python_Lock_Vim(void)
-{
-}
-/*
-* release a lock on the Vim data structures
-*/
-static void Python_Release_Vim(void)
-{
-}
-void python3_end()
 {
 static int recurse = 0;
 /* If a crash occurs while doing this, don't try again. */
 if (recurse != 0)
 {
 return (hinstPy3 != 0);
 }
 #endif
-static int Python3_Init(void)
+static int
+Python3_Init(void)
 {
 if (!py3initialised)
 {
 #ifdef DYNAMIC_PYTHON3
 	if (!python3_enabled(TRUE))
 }
 /*
 * External interface
 */
-static void DoPy3Command(exarg_T *eap, const char *cmd)
+static void
+DoPy3Command(exarg_T *eap, const char *cmd)
 {
 #if defined(MACOS) && !defined(MACOS_X_UNIX)
 GrafPtr		oldPort;
 #endif
 #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
 }
 /*
 * ":py3"
 */
-void ex_py3(exarg_T *eap)
+void
+ex_py3(exarg_T *eap)
 {
 char_u *script;
 script = script_get(eap, eap->arg);
 if (!eap->skip)
 */
 static PyObject *OutputGetattro(PyObject *, PyObject *);
 static int OutputSetattro(PyObject *, PyObject *, PyObject *);
-static PyObject *OutputWrite(PyObject *, PyObject *);
-static PyObject *OutputWritelines(PyObject *, PyObject *);
-typedef void (*writefn)(char_u *);
-static void writer(writefn fn, char_u *str, Py_ssize_t n);
-/* Output object definition
-*/
-typedef struct
-{
-PyObject_HEAD
-long softspace;
-long error;
-} OutputObject;
-static struct PyMethodDef OutputMethods[] = {
-/* name,	    function,		calling,    documentation */
-{"write",	    OutputWrite,	1,	    "" },
-{"writelines",  OutputWritelines,	1,	    "" },
-{ NULL,	    NULL,		0,	    NULL }
-};
-static PyTypeObject OutputType;
 /*************/
-static PyObject * OutputGetattro(PyObject *self, PyObject *nameobj)
+static PyObject *
+OutputGetattro(PyObject *self, PyObject *nameobj)
 {
 char *name = "";
 if (PyUnicode_Check(nameobj))
 	name = _PyUnicode_AsString(nameobj);
 	return PyLong_FromLong(((OutputObject *)(self))->softspace);
 return PyObject_GenericGetAttr(self, nameobj);
 }
-static int OutputSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
+static int
+OutputSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
 {
 char *name = "";
 if (PyUnicode_Check(nameobj))
 	name = _PyUnicode_AsString(nameobj);
 PyErr_SetString(PyExc_AttributeError, _("invalid attribute"));
 return -1;
 }
-/*************/
-static PyObject * OutputWrite(PyObject *self, PyObject *args)
-{
-int len;
-char *str;
-int error = ((OutputObject *)(self))->error;
-if (!PyArg_ParseTuple(args, "s#", &str, &len))
-	return NULL;
-Py_BEGIN_ALLOW_THREADS
-Python_Lock_Vim();
-writer((writefn)(error ? emsg : msg), (char_u *)str, len);
-Python_Release_Vim();
-Py_END_ALLOW_THREADS
-Py_INCREF(Py_None);
-return Py_None;
-}
-static PyObject * OutputWritelines(PyObject *self, PyObject *args)
-{
-Py_ssize_t n;
-Py_ssize_t i;
-PyObject *list;
-int error = ((OutputObject *)(self))->error;
-if (!PyArg_ParseTuple(args, "O", &list))
-	return NULL;
-Py_INCREF(list);
-if (!PyList_Check(list)) {
-	PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
-	Py_DECREF(list);
-	return NULL;
-}
-n = PyList_Size(list);
-for (i = 0; i < n; ++i)
-{
-	PyObject *line = PyList_GetItem(list, i);
-	char *str;
-	Py_ssize_t len;
-	if (!PyArg_Parse(line, "s#", &str, &len)) {
-	    PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
-	    Py_DECREF(list);
-	    return NULL;
-	}
-	Py_BEGIN_ALLOW_THREADS
-	    Python_Lock_Vim();
-	writer((writefn)(error ? emsg : msg), (char_u *)str, len);
-	Python_Release_Vim();
-	Py_END_ALLOW_THREADS
-}
-Py_DECREF(list);
-Py_INCREF(Py_None);
-return Py_None;
-}
-/* Output buffer management
-*/
-static char_u *buffer = NULL;
-static Py_ssize_t buffer_len = 0;
-static Py_ssize_t buffer_size = 0;
-static writefn old_fn = NULL;
-static void buffer_ensure(Py_ssize_t n)
-{
-Py_ssize_t new_size;
-char_u *new_buffer;
-if (n < buffer_size)
-	return;
-new_size = buffer_size;
-while (new_size < n)
-	new_size += 80;
-if (new_size != buffer_size)
-{
-	new_buffer = alloc((unsigned)new_size);
-	if (new_buffer == NULL)
-	    return;
-	if (buffer)
-	{
-	    memcpy(new_buffer, buffer, buffer_len);
-	    vim_free(buffer);
-	}
-	buffer = new_buffer;
-	buffer_size = new_size;
-}
-}
-static void PythonIO_Flush(void)
-{
-if (old_fn && buffer_len)
-{
-	buffer[buffer_len] = 0;
-	old_fn(buffer);
-}
-buffer_len = 0;
-}
-static void writer(writefn fn, char_u *str, Py_ssize_t n)
-{
-char_u *ptr;
-if (fn != old_fn && old_fn != NULL)
-	PythonIO_Flush();
-old_fn = fn;
-while (n > 0 && (ptr = memchr(str, '\n', n)) != NULL)
-{
-	Py_ssize_t len = ptr - str;
-	buffer_ensure(buffer_len + len + 1);
-	memcpy(buffer + buffer_len, str, len);
-	buffer_len += len;
-	buffer[buffer_len] = 0;
-	fn(buffer);
-	str = ptr + 1;
-	n -= len + 1;
-	buffer_len = 0;
-}
-/* Put the remaining text into the buffer for later printing */
-buffer_ensure(buffer_len + n + 1);
-memcpy(buffer + buffer_len, str, n);
-buffer_len += n;
-}
 /***************/
-static OutputObject Output =
+static int
-{
+PythonIO_Init(void)
-PyObject_HEAD_INIT(&OutputType)
-0,
-0
-};
-static OutputObject Error =
-{
-PyObject_HEAD_INIT(&OutputType)
-0,
-1
-};
-static int PythonIO_Init(void)
 {
 PyType_Ready(&OutputType);
+return PythonIO_Init_io();
-PySys_SetObject("stdout", (PyObject *)(void *)&Output);
+}
-PySys_SetObject("stderr", (PyObject *)(void *)&Error);
+static void
-if (PyErr_Occurred())
+PythonIO_Fini(void)
-{
-	EMSG(_("E264: Python: Error initialising I/O objects"));
-	return -1;
-}
-return 0;
-}
-static void PythonIO_Fini(void)
 {
 PySys_SetObject("stdout", NULL);
 PySys_SetObject("stderr", NULL);
 }
 */
 /* Vim module - Implementation functions
 * -------------------------------------
 */
-static PyObject *VimError;
 static PyObject *VimCommand(PyObject *, PyObject *);
 static PyObject *VimEval(PyObject *, PyObject *);
 /* Window type - Implementation functions
 /* Vim module - Definitions
 */
 static struct PyMethodDef VimMethods[] = {
 /* name,	     function,		calling,    documentation */
-{"command",      VimCommand,	1,	    "Execute a Vim ex-mode command" },
+{"command",	     VimCommand,	1,	    "Execute a Vim ex-mode command" },
 {"eval",	     VimEval,		1,	    "Evaluate an expression using Vim evaluator" },
 { NULL,	     NULL,		0,	    NULL }
 };
 /* Vim module - Implementation
 */
-/*ARGSUSED*/
+static PyObject *
-static PyObject * VimCommand(PyObject *self UNUSED, PyObject *args)
+VimCommand(PyObject *self UNUSED, PyObject *args)
 {
 char *cmd;
 PyObject *result;
 if (!PyArg_ParseTuple(args, "s", &cmd))
 * 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 *lookupDict)
+static PyObject *
-{
+VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
-PyObject    *result;
+{
-PyObject    *newObj;
+PyObject	*result;
+PyObject	*newObj;
 char	ptrBuf[NUMBUFLEN];
 /* Avoid infinite recursion */
 if (depth > 100)
 {
 {
 	result = PyDict_New();
 	if (our_tv->vval.v_dict != NULL)
 	{
-	    hashtab_T   *ht = &our_tv->vval.v_dict->dv_hashtab;
+	    hashtab_T	*ht = &our_tv->vval.v_dict->dv_hashtab;
-	    long_u      t = ht->ht_used;
+	    long_u	todo = ht->ht_used;
-	    hashitem_T  *hi;
+	    hashitem_T	*hi;
-	    dictitem_T  *di;
+	    dictitem_T	*di;
 	    PyDict_SetItemString(lookupDict, ptrBuf, result);
-	    for (hi = ht->ht_array; t > 0; ++hi)
+	    for (hi = ht->ht_array; todo > 0; ++hi)
 	    {
 		if (!HASHITEM_EMPTY(hi))
 		{
-		    --t;
+		    --todo;
 		    di = dict_lookup(hi);
 		    newObj = VimToPython(&di->di_tv, depth + 1, lookupDict);
 		    PyDict_SetItemString(result, (char *)hi->hi_key, newObj);
 		    Py_DECREF(newObj);
 return result;
 }
 #endif
-/*ARGSUSED*/
+static PyObject *
-static PyObject * VimEval(PyObject *self UNUSED, PyObject *args)
+VimEval(PyObject *self UNUSED, PyObject *args)
 {
 #ifdef FEAT_EVAL
 char	*expr;
-typval_T    *our_tv;
+typval_T	*our_tv;
-PyObject    *result;
+PyObject	*result;
 PyObject    *lookup_dict;
 if (!PyArg_ParseTuple(args, "s", &expr))
 	return NULL;
 /* Common routines for buffers and line ranges
 * -------------------------------------------
 */
-static int CheckBuffer(BufferObject *this)
+static int
+CheckBuffer(BufferObject *this)
 {
 if (this->buf == INVALID_BUFFER_VALUE)
 {
 	PyErr_SetVim(_("attempt to refer to deleted buffer"));
 	return -1;
 }
 return 0;
 }
-static PyObject * RBItem(BufferObject *self, Py_ssize_t n, Py_ssize_t start, Py_ssize_t end)
+static PyObject *
+RBItem(BufferObject *self, Py_ssize_t n, Py_ssize_t start, Py_ssize_t end)
 {
 if (CheckBuffer(self))
 	return NULL;
 if (n < 0 || n > end - start)
 }
 return GetBufferLine(self->buf, n+start);
 }
-static Py_ssize_t RBAsItem(BufferObject *self, Py_ssize_t n, PyObject *val, Py_ssize_t start, Py_ssize_t end, Py_ssize_t *new_end)
+static PyObject *
-{
+RBSlice(BufferObject *self, Py_ssize_t lo, Py_ssize_t hi, Py_ssize_t start, Py_ssize_t end)
-Py_ssize_t len_change;
-if (CheckBuffer(self))
-	return -1;
-if (n < 0 || n > end - start)
-{
-	PyErr_SetString(PyExc_IndexError, _("line number out of range"));
-	return -1;
-}
-if (SetBufferLine(self->buf, n+start, val, &len_change) == FAIL)
-	return -1;
-if (new_end)
-	*new_end = end + len_change;
-return 0;
-}
-static PyObject * RBSlice(BufferObject *self, Py_ssize_t lo, Py_ssize_t hi, Py_ssize_t start, Py_ssize_t end)
 {
 Py_ssize_t size;
 if (CheckBuffer(self))
 	return NULL;
 	hi = size;
 return GetBufferLineList(self->buf, lo+start, hi+start);
 }
-static PyObject * RBAppend(BufferObject *self, PyObject *args, Py_ssize_t start, Py_ssize_t end, Py_ssize_t *new_end)
+static Py_ssize_t
+RBAsItem(BufferObject *self, Py_ssize_t n, PyObject *val, Py_ssize_t start, Py_ssize_t end, Py_ssize_t *new_end)
+{
+Py_ssize_t len_change;
+if (CheckBuffer(self))
+	return -1;
+if (n < 0 || n > end - start)
+{
+	PyErr_SetString(PyExc_IndexError, _("line number out of range"));
+	return -1;
+}
+if (SetBufferLine(self->buf, n+start, val, &len_change) == FAIL)
+	return -1;
+if (new_end)
+	*new_end = end + len_change;
+return 0;
+}
+static PyObject *
+RBAppend(BufferObject *self, PyObject *args, Py_ssize_t start, Py_ssize_t end, Py_ssize_t *new_end)
 {
 PyObject *lines;
 Py_ssize_t len_change;
 Py_ssize_t max;
 Py_ssize_t n;
 Py_INCREF(Py_None);
 return Py_None;
 }
+/* Buffer object - Definitions
+*/
 static struct PyMethodDef BufferMethods[] = {
 /* name,	    function,		calling,    documentation */
 {"append",	    BufferAppend,	1,	    "Append data to Vim buffer" },
 {"mark",	    BufferMark,		1,	    "Return (row,col) representing position of named mark" },
 /* Buffer object - Definitions
 */
 static PyTypeObject BufferType;
-static PyObject * BufferNew(buf_T *buf)
+static PyObject *
+BufferNew(buf_T *buf)
 {
 /* We need to handle deletion of buffers underneath us.
 * If we add a "b_python3_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
 }
 return (PyObject *)(self);
 }
-static void BufferDestructor(PyObject *self)
+static void
+BufferDestructor(PyObject *self)
 {
 BufferObject *this = (BufferObject *)(self);
 if (this->buf && this->buf != INVALID_BUFFER_VALUE)
 	this->buf->b_python3_ref = NULL;
 }
-static PyObject * BufferGetattro(PyObject *self, PyObject*nameobj)
+static PyObject *
+BufferGetattro(PyObject *self, PyObject*nameobj)
 {
 BufferObject *this = (BufferObject *)(self);
 char *name = "";
 if (PyUnicode_Check(nameobj))
 	return Py_BuildValue("[ss]", "name", "number");
 else
 	return PyObject_GenericGetAttr(self, nameobj);
 }
-static PyObject * BufferRepr(PyObject *self)
+static PyObject *
+BufferRepr(PyObject *self)
 {
 static char repr[100];
 BufferObject *this = (BufferObject *)(self);
 if (this->buf == INVALID_BUFFER_VALUE)
 }
 }
 /******************/
-static Py_ssize_t BufferLength(PyObject *self)
+static Py_ssize_t
+BufferLength(PyObject *self)
 {
 if (CheckBuffer((BufferObject *)(self)))
 	return -1;
 return (Py_ssize_t)(((BufferObject *)(self))->buf->b_ml.ml_line_count);
 }
-static PyObject * BufferItem(PyObject *self, Py_ssize_t n)
+static PyObject *
+BufferItem(PyObject *self, Py_ssize_t n)
 {
 return RBItem((BufferObject *)(self), n, 1,
 	       (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count);
 }
-static Py_ssize_t BufferAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
+static PyObject *
+BufferSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi)
+{
+return RBSlice((BufferObject *)(self), lo, hi, 1,
+	       (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count);
+}
+static Py_ssize_t
+BufferAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
 {
 return RBAsItem((BufferObject *)(self), n, val, 1,
 		(Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
 		NULL);
 }
-static PyObject * BufferSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi)
-{
+static PyObject *
-return RBSlice((BufferObject *)(self), lo, hi, 1,
+BufferSubscript(PyObject *self, PyObject* idx)
-	       (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count);
-}
-static PyObject* BufferSubscript(PyObject *self, PyObject* idx)
 {
 if (PyLong_Check(idx)) {
 	long _idx = PyLong_AsLong(idx);
 	return BufferItem(self,_idx);
 } else if (PySlice_Check(idx)) {
 	PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
 	return NULL;
 }
 }
-static PyObject * BufferAppend(PyObject *self, PyObject *args)
+static PyObject *
+BufferAppend(PyObject *self, PyObject *args)
 {
 return RBAppend((BufferObject *)(self), args, 1,
 		(Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
 		NULL);
 }
-static PyObject * BufferMark(PyObject *self, PyObject *args)
+static PyObject *
+BufferMark(PyObject *self, PyObject *args)
 {
 pos_T       *posp;
 char	*pmark;//test
 char	mark;
 buf_T       *curbuf_save;
 }
 return Py_BuildValue("(ll)", (long)(posp->lnum), (long)(posp->col));
 }
-static PyObject * BufferRange(PyObject *self, PyObject *args)
+static PyObject *
+BufferRange(PyObject *self, PyObject *args)
 {
 Py_ssize_t start;
 Py_ssize_t end;
 if (CheckBuffer((BufferObject *)(self)))
 static PyTypeObject RangeType;
 /* Line range object - Implementation
 */
-static PyObject * RangeNew(buf_T *buf, Py_ssize_t start, Py_ssize_t end)
+static PyObject *
+RangeNew(buf_T *buf, Py_ssize_t start, Py_ssize_t end)
 {
 BufferObject *bufr;
 RangeObject *self;
 self = PyObject_NEW(RangeObject, &RangeType);
 if (self == NULL)
 self->end = end;
 return (PyObject *)(self);
 }
-static void RangeDestructor(PyObject *self)
+static void
+RangeDestructor(PyObject *self)
 {
 Py_DECREF(((RangeObject *)(self))->buf);
 }
-static PyObject * RangeGetattro(PyObject *self, PyObject *nameobj)
+static PyObject *
+RangeGetattro(PyObject *self, PyObject *nameobj)
 {
 char *name = "";
 if (PyUnicode_Check(nameobj))
 	name = _PyUnicode_AsString(nameobj);
 	return Py_BuildValue("n", ((RangeObject *)(self))->end - 1);
 else
 	return PyObject_GenericGetAttr(self, nameobj);
 }
-static PyObject * RangeRepr(PyObject *self)
+static PyObject *
+RangeRepr(PyObject *self)
 {
 static char repr[100];
 RangeObject *this = (RangeObject *)(self);
 if (this->buf->buf == INVALID_BUFFER_VALUE)
 }
 }
 /****************/
-static Py_ssize_t RangeLength(PyObject *self)
+static Py_ssize_t
+RangeLength(PyObject *self)
 {
 /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
 if (CheckBuffer(((RangeObject *)(self))->buf))
 	return -1; /* ??? */
 return (((RangeObject *)(self))->end - ((RangeObject *)(self))->start + 1);
 }
-static PyObject * RangeItem(PyObject *self, Py_ssize_t n)
+static PyObject *
+RangeItem(PyObject *self, Py_ssize_t n)
 {
 return RBItem(((RangeObject *)(self))->buf, n,
 		  ((RangeObject *)(self))->start,
 		  ((RangeObject *)(self))->end);
 }
-static Py_ssize_t RangeAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
+static Py_ssize_t
+RangeAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
 {
 return RBAsItem(((RangeObject *)(self))->buf, n, val,
 		    ((RangeObject *)(self))->start,
 		    ((RangeObject *)(self))->end,
 		    &((RangeObject *)(self))->end);
 }
-static PyObject * RangeSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi)
+static PyObject *
+RangeSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi)
 {
 return RBSlice(((RangeObject *)(self))->buf, lo, hi,
 		   ((RangeObject *)(self))->start,
 		   ((RangeObject *)(self))->end);
 }
-static PyObject* RangeSubscript(PyObject *self, PyObject* idx)
+static PyObject *
+RangeSubscript(PyObject *self, PyObject* idx)
 {
 if (PyLong_Check(idx)) {
 	long _idx = PyLong_AsLong(idx);
 	return RangeItem(self,_idx);
 } else if (PySlice_Check(idx)) {
 	PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
 	return NULL;
 }
 }
-static PyObject * RangeAppend(PyObject *self, PyObject *args)
+static PyObject *
+RangeAppend(PyObject *self, PyObject *args)
 {
 return RBAppend(((RangeObject *)(self))->buf, args,
 		    ((RangeObject *)(self))->start,
 		    ((RangeObject *)(self))->end,
 		    &((RangeObject *)(self))->end);
 static PyTypeObject BufListType;
 /* Buffer list object - Implementation
 */
-/*ARGSUSED*/
+static Py_ssize_t
-static Py_ssize_t BufListLength(PyObject *self UNUSED)
+BufListLength(PyObject *self UNUSED)
 {
 buf_T       *b = firstbuf;
 Py_ssize_t  n = 0;
 while (b)
 }
 return n;
 }
-/*ARGSUSED*/
+static PyObject *
-static PyObject * BufListItem(PyObject *self UNUSED, Py_ssize_t n)
+BufListItem(PyObject *self UNUSED, Py_ssize_t n)
 {
 buf_T *b;
 for (b = firstbuf; b; b = b->b_next, --n)
 {
 static PyTypeObject WindowType;
 /* Window object - Implementation
 */
-static PyObject * WindowNew(win_T *win)
+static PyObject *
+WindowNew(win_T *win)
 {
 /* We need to handle deletion of windows underneath us.
 * If we add a "w_python3_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
 }
 return (PyObject *)(self);
 }
-static void WindowDestructor(PyObject *self)
+static void
+WindowDestructor(PyObject *self)
 {
 WindowObject *this = (WindowObject *)(self);
 if (this->win && this->win != INVALID_WINDOW_VALUE)
 	this->win->w_python3_ref = NULL;
 }
-static int CheckWindow(WindowObject *this)
+static int
+CheckWindow(WindowObject *this)
 {
 if (this->win == INVALID_WINDOW_VALUE)
 {
 	PyErr_SetVim(_("attempt to refer to deleted window"));
 	return -1;
 }
 return 0;
 }
-static PyObject * WindowGetattro(PyObject *self, PyObject *nameobj)
+static PyObject *
+WindowGetattro(PyObject *self, PyObject *nameobj)
 {
 WindowObject *this = (WindowObject *)(self);
 char *name = "";
 if (PyUnicode_Check(nameobj))
 	return Py_BuildValue("[sss]", "buffer", "cursor", "height");
 else
 	return PyObject_GenericGetAttr(self, nameobj);
 }
-static int WindowSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
+static int
+WindowSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
 {
 WindowObject *this = (WindowObject *)(self);
 char *name = "";
 if (PyUnicode_Check(nameobj))
 	return 0;
 }
 else if (strcmp(name, "height") == 0)
 {
-	int     height;
+	int	height;
-	win_T   *savewin;
+	win_T	*savewin;
 	if (!PyArg_Parse(val, "i", &height))
 	    return -1;
 #ifdef FEAT_GUI
 	return 0;
 }
 #ifdef FEAT_VERTSPLIT
 else if (strcmp(name, "width") == 0)
 {
-	int     width;
+	int	width;
-	win_T   *savewin;
+	win_T	*savewin;
 	if (!PyArg_Parse(val, "i", &width))
 	    return -1;
 #ifdef FEAT_GUI
 	PyErr_SetString(PyExc_AttributeError, name);
 	return -1;
 }
 }
-static PyObject * WindowRepr(PyObject *self)
+static PyObject *
+WindowRepr(PyObject *self)
 {
 static char repr[100];
 WindowObject *this = (WindowObject *)(self);
 if (this->win == INVALID_WINDOW_VALUE)
 	vim_snprintf(repr, 100, _("<window object (deleted) at %p>"), (self));
 	return PyUnicode_FromString(repr);
 }
 else
 {
-	int     i = 0;
+	int	i = 0;
-	win_T   *w;
+	win_T	*w;
 	for (w = firstwin; w != NULL && w != this->win; w = W_NEXT(w))
 	    ++i;
 	if (w == NULL)
 static PyTypeObject WinListType;
 /* Window list object - Implementation
 */
-/*ARGSUSED*/
+static Py_ssize_t
-static Py_ssize_t WinListLength(PyObject *self UNUSED)
+WinListLength(PyObject *self UNUSED)
 {
 win_T       *w = firstwin;
 Py_ssize_t  n = 0;
 while (w != NULL)
 }
 return n;
 }
-/*ARGSUSED*/
+static PyObject *
-static PyObject * WinListItem(PyObject *self UNUSED, Py_ssize_t n)
+WinListItem(PyObject *self UNUSED, Py_ssize_t n)
 {
 win_T *w;
 for (w = firstwin; w != NULL; w = W_NEXT(w), --n)
 	if (n == 0)
 static PyTypeObject CurrentType;
 /* Current items object - Implementation
 */
-/*ARGSUSED*/
+static PyObject *
-static PyObject * CurrentGetattro(PyObject *self UNUSED, PyObject *nameobj)
+CurrentGetattro(PyObject *self UNUSED, PyObject *nameobj)
 {
 char *name = "";
 if (PyUnicode_Check(nameobj))
 	name = _PyUnicode_AsString(nameobj);
 	PyErr_SetString(PyExc_AttributeError, name);
 	return NULL;
 }
 }
-/*ARGSUSED*/
+static int
-static int CurrentSetattro(PyObject *self UNUSED, PyObject *nameobj, PyObject *value)
+CurrentSetattro(PyObject *self UNUSED, PyObject *nameobj, PyObject *value)
 {
 char *name = "";
 if (PyUnicode_Check(nameobj))
 	name = _PyUnicode_AsString(nameobj);
 /*************************************************************************
 * 4. Utility functions for handling the interface between Vim and Python.
 */
+/* 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, Py_ssize_t 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, Py_ssize_t lo, Py_ssize_t hi)
+static PyObject *
+GetBufferLineList(buf_T *buf, Py_ssize_t lo, Py_ssize_t hi)
 {
 Py_ssize_t i;
 Py_ssize_t n = hi - lo;
 PyObject *list = PyList_New(n);
 */
 return list;
 }
-/* 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, Py_ssize_t n)
-{
-return LineToString((char *)ml_get_buf(buf, (linenr_T)n, FALSE));
-}
 /*
 * 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)
+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. */
 * 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, Py_ssize_t n, PyObject *line, Py_ssize_t *len_change)
+static int
+SetBufferLine(buf_T *buf, Py_ssize_t n, PyObject *line, Py_ssize_t *len_change)
 {
 /* First of all, we check the thpe of the supplied Python object.
 * There are three cases:
 *    1. NULL, or None - this is a deletion.
 *    2. A string      - this is a replacement.
 * 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, Py_ssize_t n, PyObject *lines, Py_ssize_t *len_change)
+static int
+InsertBufferLines(buf_T *buf, Py_ssize_t n, PyObject *lines, Py_ssize_t *len_change)
 {
 /* 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 (PyUnicode_Check(lines))
 /* Convert a Vim line into a Python string.
 * All internal newlines are replaced by null characters.
 *
 * On errors, the Python exception data is set, and NULL is returned.
 */
-static PyObject * LineToString(const char *str)
+static PyObject *
+LineToString(const char *str)
 {
 PyObject *result;
 Py_ssize_t len = strlen(str);
 char *tmp,*p;
 * 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)
+static char *
+StringToLine(PyObject *obj)
 {
 const char *str;
 char *save;
 Py_ssize_t len;
 Py_ssize_t i;
 save[i] = '\0';
 return save;
 }
-/* Check to see whether a Vim error has been reported, or a keyboard
+static void
-* interrupt has been detected.
+init_structs(void)
-*/
-static int VimErrorCheck(void)
-{
-if (got_int)
-{
-	PyErr_SetNone(PyExc_KeyboardInterrupt);
-	return 1;
-}
-else if (did_emsg && !PyErr_Occurred())
-{
-	PyErr_SetNone(VimError);
-	return 1;
-}
-return 0;
-}
-static void init_structs(void)
 {
 vim_memset(&OutputType, 0, sizeof(OutputType));
 OutputType.tp_name = "vim.message";
 OutputType.tp_basicsize = sizeof(OutputObject);
 OutputType.tp_getattro = OutputGetattro;

Mercurial > vim

comparison src/if_python3.c @ 2399:76f0c4918f5c vim73