vim: src/if_py_both.h comparison

comparison src/if_py_both.h @ 18753:6e3dc2d630c2 v8.1.2366

patch 8.1.2366: using old C style comments Commit: https://github.com/vim/vim/commit/9bf703d46a79fbffeb829246ea5ce385bddc4166 Author: Bram Moolenaar <Bram@vim.org> Date: Sat Nov 30 19:44:38 2019 +0100 patch 8.1.2366: using old C style comments Problem: Using old C style comments. Solution: Use // comments where appropriate.

author	Bram Moolenaar <Bram@vim.org>
date	Sat, 30 Nov 2019 19:45:03 +0100
parents	026034963159
children	a3d9a5e14c1f

comparison

equal deleted inserted replaced

-:9ec3c9cb4533
+:6e3dc2d630c2
 */
 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. */
+typedef int Py_ssize_t;  // Python 2.4 and earlier don't have this type.
 #endif
 #define ENC_OPT ((char *)p_enc)
 #define DOPY_FUNC "_vim_pydo"
 #endif
 return ret;
 }
-/* Output buffer management
+// Output buffer management
-*/
+// Function to write a line, points to either msg() or emsg().
-/* Function to write a line, points to either msg() or emsg(). */
 typedef void (*writefn)(char_u *);
 static PyTypeObject OutputType;
 typedef struct
 PyErr_FORMAT(PyExc_AttributeError, N_("invalid attribute: %s"), name);
 return -1;
 }
-/* Buffer IO, we write one whole line at a time. */
+// 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)
 static void
 writer(writefn fn, char_u *str, PyInt n)
 {
 char_u *ptr;
-/* Flush when switching output function. */
+// 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
 	Py_DECREF(item);
 }
 Py_DECREF(iterator);
-/* Iterator may have finished due to an exception */
+// 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 */
+// do nothing
 Py_INCREF(Py_None);
 return Py_None;
 }
 static PyObject *
 AlwaysFalse(PyObject *self UNUSED)
 {
-/* do nothing */
+// do nothing
 PyObject	*ret = Py_False;
 Py_INCREF(ret);
 return ret;
 }
 static PyObject *
 AlwaysTrue(PyObject *self UNUSED)
 {
-/* do nothing */
+// do nothing
 PyObject	*ret = Py_True;
 Py_INCREF(ret);
 return ret;
 }
 /***************/
 static struct PyMethodDef OutputMethods[] = {
-/* name,	    function,				calling,	doc */
+// 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,	""},
 Py_INCREF(module);
 return module;
 }
 static struct PyMethodDef LoaderMethods[] = {
-/* name,	    function,				calling,	doc */
+// 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
+/*
+* 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
+// 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
+// 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 */
+// Keyboard interrupt should be preferred over anything else
 if (got_int)
 {
 	if (did_throw)
 	    discard_current_exception();
 	got_int = FALSE;
 	return -1;
 }
 else if (!did_throw)
 	return (PyErr_Occurred() ? -1 : 0);
-/* Python exception is preferred over vim one; unlikely to occur though */
+// 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 */
+// Finally transform Vim script exception to python one
 else
 {
 	PyErr_SetVim((char *)current_exception->value);
 	discard_current_exception();
 	return -1;
 	return 1;
 }
 return 0;
 }
-/* Vim module - Implementation
+// Vim module - Implementation
-*/
 static PyObject *
 VimCommand(PyObject *self UNUSED, PyObject *string)
 {
 char_u	*cmd;
 {
 PyObject	*ret;
 PyObject	*newObj;
 char	ptrBuf[sizeof(void *) * 2 + 3];
-/* Avoid infinite recursion */
+// 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
+// Check if we run into a recursive loop.  The item must be in lookup_dict
-* then and we can use it again. */
+// 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
 					? "" : (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. */
+	// 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)
 {
 	PyErr_SET_VIM(N_("invalid expression"));
 	return NULL;
 }
-/* Convert the Vim type into a Python type.  Create a dictionary that's
+// Convert the Vim type into a Python type.  Create a dictionary that's
-* used to check for recursive loops. */
+// used to check for recursive loops.
 if (!(lookup_dict = PyDict_New()))
 	ret = NULL;
 else
 {
 	ret = VimToPython(our_tv, 1, lookup_dict);
 #else
 # define PY_MAIN_DIR_STRING "python3"
 #endif
 #define PY_ALTERNATE_DIR_STRING "pythonx"
-#define PYTHONX_STRING_LENGTH 7 /* STRLEN("pythonx") */
+#define PYTHONX_STRING_LENGTH 7 // STRLEN("pythonx")
 if (!(pathbuf = PyMem_New(char,
 		    pathlen + STRLEN(PATHSEPSTR) + PYTHONX_STRING_LENGTH + 1)))
 {
 	PyErr_NoMemory();
 	*data = NULL;
 /*
 * Vim module - Definitions
 */
 static struct PyMethodDef VimMethods[] = {
-/* name,	    function,			calling,			documentation */
+// 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"},
 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
+// Main purpose of this object is removing the need for do python
-* initialization (i.e. PyType_Ready and setting type attributes) for a big
+// initialization (i.e. PyType_Ready and setting type attributes) for a big
-* bunch of objects. */
+// bunch of objects.
 typedef struct
 {
 PyObject_HEAD
 void *cur;
 nextfun next;
 	return self->traverse(self->cur, visit, arg);
 else
 	return 0;
 }
-/* Mac OSX defines clear() somewhere. */
+// Mac OSX defines clear() somewhere.
 #ifdef clear
 # undef clear
 #endif
 static int
 }
 #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_BOOL	0x08 // Incompatible with DICT_FLAG_POP
 #define DICT_FLAG_RETURN_PAIR	0x10
 static PyObject *
 _DictionaryItem(DictionaryObject *self, PyObject *args, int flags)
 {
 		}
 	    }
 	    Py_DECREF(iterator);
-	    /* Iterator may have finished due to an exception */
+	    // Iterator may have finished due to an exception
 	    if (PyErr_Occurred())
 		return NULL;
 	}
 }
 Py_INCREF(Py_None);
 {
 return _DictionaryItem(self, keyObject, DICT_FLAG_RETURN_BOOL);
 }
 static PySequenceMethods DictionaryAsSeq = {
-0,					/* sq_length */
+0,					// sq_length
-0,					/* sq_concat */
+0,					// sq_concat
-0,					/* sq_repeat */
+0,					// sq_repeat
-0,					/* sq_item */
+0,					// sq_item
-0,					/* sq_slice */
+0,					// sq_slice
-0,					/* sq_ass_item */
+0,					// sq_ass_item
-0,					/* sq_ass_slice */
+0,					// sq_ass_slice
-(objobjproc) DictionaryContains,	/* sq_contains */
+(objobjproc) DictionaryContains,	// sq_contains
-0,					/* sq_inplace_concat */
+0,					// sq_inplace_concat
-0,					/* sq_inplace_repeat */
+0,					// sq_inplace_repeat
 };
 static PyMappingMethods DictionaryAsMapping = {
 (lenfunc)       DictionaryLength,
 (binaryfunc)    DictionaryItem,
 	list_append(l, li);
 }
 Py_DECREF(iterator);
-/* Iterator may have finished due to an exception */
+// Iterator may have finished due to an exception
 if (PyErr_Occurred())
 	return -1;
 return 0;
 }
 	return NULL;
 }
 li = list_find(self->list, (long) index);
 if (li == NULL)
 {
-	/* No more suitable format specifications in python-2.3 */
+	// 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);
 	return -1;
 }
 if (step != 1 && slicelen == 0)
 {
-	/* Nothing to do. Only error out if obj has some items. */
+	// Nothing to do. Only error out if obj has some items.
 	int		ret = 0;
 	if (obj == NULL)
 	    return 0;
 	Py_DECREF(iterator);
 	return ret;
 }
 if (obj != NULL)
-	/* XXX May allocate zero bytes. */
+	// XXX May allocate zero bytes.
 	if (!(lis = PyMem_New(listitem_T *, slicelen * 2)))
 	{
 	    PyErr_NoMemory();
 	    return -1;
 	}
 	return -1;
 }
 }
 static PySequenceMethods ListAsSeq = {
-(lenfunc)		ListLength,	 /* sq_length,	  len(x)   */
+(lenfunc)		ListLength,	 // sq_length,	  len(x)
-(binaryfunc)	0,		 /* RangeConcat, sq_concat,  x+y   */
+(binaryfunc)	0,		 // RangeConcat, sq_concat,  x+y
-0,					 /* RangeRepeat, sq_repeat,  x*n   */
+0,					 // RangeRepeat, sq_repeat,  x*n
-(PyIntArgFunc)	ListIndex,	 /* sq_item,	  x[i]	   */
+(PyIntArgFunc)	ListIndex,	 // sq_item,	  x[i]
-0,					 /* was_sq_slice,     x[i:j]   */
+0,					 // was_sq_slice,     x[i:j]
-(PyIntObjArgProc)	ListAssIndex,	 /* sq_as_item,  x[i]=v   */
+(PyIntObjArgProc)	ListAssIndex,	 // sq_as_item,  x[i]=v
-0,					 /* was_sq_ass_slice, x[i:j]=v */
+0,					 // was_sq_ass_slice, x[i:j]=v
-0,					 /* sq_contains */
+0,					 // sq_contains
-(binaryfunc)	ListConcatInPlace,/* sq_inplace_concat */
+(binaryfunc)	ListConcatInPlace,// sq_inplace_concat
-0,					 /* sq_inplace_repeat */
+0,					 // sq_inplace_repeat
 };
 static PyMappingMethods ListAsMapping = {
 /* mp_length	*/ (lenfunc) ListLength,
 /* mp_subscript     */ (binaryfunc) ListItem,
 else if (strcmp(name, "__members__") == 0)
 	return ObjectDir(NULL, FunctionAttrs);
 return NULL;
 }
-/* Populate partial_T given function object.
+/*
+* 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
 return ret;
 }
 static PySequenceMethods OptionsAsSeq = {
-0,					/* sq_length */
+0,					// sq_length
-0,					/* sq_concat */
+0,					// sq_concat
-0,					/* sq_repeat */
+0,					// sq_repeat
-0,					/* sq_item */
+0,					// sq_item
-0,					/* sq_slice */
+0,					// sq_slice
-0,					/* sq_ass_item */
+0,					// sq_ass_item
-0,					/* sq_ass_slice */
+0,					// sq_ass_slice
-(objobjproc) OptionsContains,	/* sq_contains */
+(objobjproc) OptionsContains,	// sq_contains
-0,					/* sq_inplace_concat */
+0,					// sq_inplace_concat
-0,					/* sq_inplace_repeat */
+0,					// sq_inplace_repeat
 };
 static PyMappingMethods OptionsAsMapping = {
 (lenfunc)       NULL,
 (binaryfunc)    OptionsItem,
 (objobjargproc) OptionsAssItem,
 };
-/* Tabpage object
+// Tabpage object
-*/
 typedef struct
 {
 PyObject_HEAD
 tabpage_T	*tab;
 	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
+	// 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);
 }
 	    return PyString_FromFormat("<tabpage %d>", t - 1);
 }
 }
 static struct PyMethodDef TabPageMethods[] = {
-/* name,	    function,			calling,	documentation */
+// name,	    function,			calling,	documentation
 {"__dir__",	    (PyCFunction)TabPageDir,	METH_NOARGS,	""},
 { NULL,	    NULL,			0,		NULL}
 };
 /*
 }
 static PyObject *
 WindowNew(win_T *win, tabpage_T *tab)
 {
-/* We need to handle deletion of windows underneath us.
+/*
+* 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
 {
 if (tabObject)
 {
 	if (CheckTabPage(tabObject))
 	    return NULL;
-	/* For current tab window.c does not bother to set or update tp_firstwin
+	// 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;
 }
 	{
 	    PyErr_SET_VIM(N_("cursor position outside buffer"));
 	    return -1;
 	}
-	/* Check for keyboard interrupts */
+	// 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. */
+	// When column is out of range silently correct it.
 	check_cursor_col_win(self->win);
 	update_screen(VALID);
 	return 0;
 }
 	    return PyString_FromFormat("<window %d>", w - 1);
 }
 }
 static struct PyMethodDef WindowMethods[] = {
-/* name,	    function,			calling,	documentation */
+// name,	    function,			calling,	documentation
 {"__dir__",	    (PyCFunction)WindowDir,	METH_NOARGS,	""},
 { NULL,	    NULL,			0,		NULL}
 };
 /*
 PyErr_SET_STRING(PyExc_IndexError, N_("no such window"));
 return NULL;
 }
-/* Convert a Python string into a Vim line.
+/*
+* 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.
 *
 	    Py_XDECREF(bytes);
 	    return NULL;
 	}
 }
-/* Create a copy of the string, with internal nulls replaced by
+/*
+* 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)
 {
 	else
 	    save[i] = str[i];
 }
 save[i] = '\0';
-Py_XDECREF(bytes);  /* Python 2 does nothing here */
+Py_XDECREF(bytes);  // Python 2 does nothing here
 return save;
 }
-/* Get a line from the specified buffer. The line number is
+/*
+* 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
+/*
+* 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)
 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? */
+	// 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 ownership of the Python list is passed to the caller (ie,
-* the caller should Py_DECREF() the object when it is finished
+// the caller should Py_DECREF() the object when it is finished
-* with it).
+// with it).
-*/
 return list;
 }
 /*
 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
+	// Adjust the cursor position if it's in/after the changed
-	 * lines. */
+	// lines.
 	if (curwin->w_cursor.lnum >= hi)
 	{
 	    curwin->w_cursor.lnum += extra;
 	    check_cursor_col();
 	}
 {
 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.
+// First of all, we check the type of the supplied Python object.
-* There are three cases:
+// There are three cases:
-*	  1. NULL, or None - this is a deletion.
+//	  1. NULL, or None - this is a deletion.
-*	  2. A string	   - this is a replacement.
+//	  2. A string	   - this is a replacement.
-*	  3. Anything else - this is an error.
+//	  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);
 					   || 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
+		// Only adjust marks if we managed to switch to a window that
-		 * holds the buffer, otherwise line numbers will be invalid. */
+		// 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 (save == NULL)
 	    return FAIL;
 	VimTryStart();
-	/* We do not need to free "save" if ml_replace() consumes it. */
+	// 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)
 	{
 	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. */
+	// Check that the cursor is not beyond the end of the line now.
 	if (buf == curbuf)
 	    check_cursor_col();
 	if (VimTryEnd())
 	    return FAIL;
 	PyErr_BadArgument();
 	return FAIL;
 }
 }
-/* Replace a range of lines in the specified buffer. The line numbers are in
+/*
+* 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
 {
 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.
+// First of all, we check the type of the supplied Python object.
-* There are three cases:
+// There are three cases:
-*	  1. NULL, or None - this is a deletion.
+//	  1. NULL, or None - this is a deletion.
-*	  2. A list	   - this is a replacement.
+//	  2. A list	   - this is a replacement.
-*	  3. Anything else - this is an error.
+//	  3. Anything else - this is an error.
-*/
 if (list == Py_None || list == NULL)
 {
 	PyInt	i;
 	PyInt	n = (int)(hi - lo);
 		    break;
 		}
 	    }
 	    if (buf == curbuf && (save_curwin != NULL
 					       || save_curbuf.br_buf == NULL))
-		/* Using an existing window for the buffer, adjust the cursor
+		// Using an existing window for the buffer, adjust the cursor
-		 * position. */
+		// 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
+		// Only adjust marks if we managed to switch to a window that
-		 * holds the buffer, otherwise line numbers will be invalid. */
+		// 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);
 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 */
+	PyInt	extra = 0;	// lines added to text, can be negative
 	char	**array;
-	if (new_len == 0)	/* avoid allocating zero bytes */
+	if (new_len == 0)	// avoid allocating zero bytes
 	    array = NULL;
 	else
 	{
 	    array = PyMem_New(char *, new_len);
 	    if (array == NULL)
 	}
 	VimTryStart();
 	PyErr_Clear();
-	/* START of region without "return".  Must call restore_buffer()! */
+	// 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
+	// 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
+	// need to delete some old_len. We do this at the start, by
-	 * repeatedly deleting line "lo".
+	// repeatedly deleting line "lo".
-	 */
 	if (!PyErr_Occurred())
 	{
 	    for (i = 0; i < old_len - new_len; ++i)
 		if (ml_delete((linenr_T)lo, FALSE) == FAIL)
 		{
 		    break;
 		}
 	    extra -= i;
 	}
-	/* For as long as possible, replace the existing old_len with the
+	// For as long as possible, replace the existing old_len with the
-	 * new old_len. This is a more efficient operation, as it requires
+	// new old_len. This is a more efficient operation, as it requires
-	 * less memory allocation and freeing.
+	// 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)
 		}
 	}
 	else
 	    i = 0;
-	/* Now we may need to insert the remaining new old_len. If we do, we
+	// 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
+	// must free the strings as we finish with them (we can't pass the
-	 * responsibility to vim in this case).
+	// responsibility to vim in this case).
-	 */
 	if (!PyErr_Occurred())
 	{
 	    while (i < new_len)
 	    {
 		if (ml_append((linenr_T)(lo + i - 1),
 		++i;
 		++extra;
 	    }
 	}
-	/* Free any left-over old_len, as a result of an error */
+	// 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
+	// Free the array of old_len. All of its contents have now
-	 * been dealt with (either freed, or the responsibility passed
+	// been dealt with (either freed, or the responsibility passed
-	 * to vim.
+	// to vim.
-	 */
 	PyMem_Free(array);
-	/* Adjust marks. Invalidate any which lie in the
+	// Adjust marks. Invalidate any which lie in the
-	 * changed range, and move any in the remainder of the buffer.
+	// changed range, and move any in the remainder of the buffer.
-	 * Only adjust marks if we managed to switch to a window that holds
+	// Only adjust marks if we managed to switch to a window that holds
-	 * the buffer, otherwise line numbers will be invalid. */
+	// 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);
 					   || 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". */
+	// END of region without "return".
 	restore_win_for_buf(save_curwin, save_curtab, &save_curbuf);
 	if (VimTryEnd())
 	    return FAIL;
 	PyErr_BadArgument();
 	return FAIL;
 }
 }
-/* Insert a number of lines into the specified buffer after the specified line.
+/*
+* 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
 {
 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.
+// 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.
+// 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)
 	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
+	    // Only adjust marks if we managed to switch to a window that
-	     * holds the buffer, otherwise line numbers will be invalid. */
+	    // 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 (ml_append((linenr_T)(n + i),
 					(char_u *)array[i], 0, FALSE) == FAIL)
 		{
 		    RAISE_INSERT_LINE_FAIL;
-		    /* Free the rest of the lines */
+		    // 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
+		// Only adjust marks if we managed to switch to a window that
-		 * holds the buffer, otherwise line numbers will be invalid. */
+		// 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
+	// Free the array of lines. All of its contents have now
-	 * been freed. */
+	// been freed.
 	PyMem_Free(array);
 	restore_win_for_buf(save_curwin, save_curtab, &save_curbuf);
 	update_screen(VALID);
 	PyInt *new_end)
 {
 PyInt size;
 PyInt len_change;
-/* Self must be a valid buffer */
+// 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 */
+// Sort out the slice range
 size = end - start + 1;
 if (lo < 0)
 	lo = 0;
 else if (lo > size)
 Py_INCREF(Py_None);
 return Py_None;
 }
-/* Range object
+// Range object
-*/
 static PyTypeObject RangeType;
 static PySequenceMethods RangeAsSeq;
 static PyMappingMethods RangeAsMapping;
 }
 static PyInt
 RangeLength(RangeObject *self)
 {
-/* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
+// HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION?
 if (CheckBuffer(self->buf))
-	return -1; /* ??? */
+	return -1; // ???
 return (self->end - self->start + 1);
 }
 static PyObject *
 				    name, (int)self->start, (int)self->end);
 }
 }
 static struct PyMethodDef RangeMethods[] = {
-/* name,	function,			calling,	documentation */
+// 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 PyMappingMethods BufferAsMapping;
 static PyObject *
 BufferNew(buf_T *buf)
 {
-/* We need to handle deletion of buffers underneath us.
+/*
+* 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
 }
 static PyInt
 BufferLength(BufferObject *self)
 {
-/* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
+// HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION?
 if (CheckBuffer(self))
-	return -1; /* ??? */
+	return -1; // ???
 return (PyInt)(self->buf->b_ml.ml_line_count);
 }
 static PyObject *
 	if (!(val = StringToChars(valObject, &todecref)))
 	    return -1;
 	VimTryStart();
-	/* Using aucmd_*: autocommands will be executed by rename_buffer */
+	// 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 NULL;
 }
 if (posp->lnum <= 0)
 {
-	/* Or raise an error? */
+	// Or raise an error?
 	Py_INCREF(Py_None);
 	return Py_None;
 }
 return Py_BuildValue("(ll)", (long)(posp->lnum), (long)(posp->col));
 	return PyString_FromFormat("<buffer %s>", name);
 }
 }
 static struct PyMethodDef BufferMethods[] = {
-/* name,	    function,			calling,	documentation */
+// 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}
 }
 static void
 BufMapIterDestruct(PyObject *buffer)
 {
-/* Iteration was stopped before all buffers were processed */
+// Iteration was stopped before all buffers were processed
 if (buffer)
 {
 	Py_DECREF(buffer);
 }
 }
 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
+// Do not increment reference: we no longer hold it (decref), but whoever
-* on other side will hold (incref). Decref+incref = nothing. */
+// on other side will hold (incref). Decref+incref = nothing.
 return ret;
 }
 static PyObject *
 BufMapIter(PyObject *self UNUSED)
 (lenfunc)       BufMapLength,
 (binaryfunc)    BufMapItem,
 (objobjargproc) 0,
 };
-/* Current items object
+// Current items object
-*/
 static char *CurrentAttrs[] = {
 "buffer", "window", "line", "range", "tabpage",
 NULL
 };
 	return -1;
 }
 }
 static struct PyMethodDef CurrentMethods[] = {
-/* name,	    function,			calling,	documentation */
+// name,	    function,			calling,	documentation
 {"__dir__",	    (PyCFunction)CurrentDir,	METH_NOARGS,	""},
 { NULL,	    NULL,			0,		NULL}
 };
 static void
 	PyObject	*ret;
 #ifdef PY_CAN_RECURSE
 	*pygilstate = PyGILState_Ensure();
 #endif
-	/* Check the line number, the command my have deleted lines. */
+	// 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);
 	Py_DECREF(linenr);
 	if (!ret)
 	    goto err;
-	/* Check that the command didn't switch to another buffer. */
+	// Check that the command didn't switch to another buffer.
 	if (curbuf != was_curbuf)
 	{
 	    Py_XDECREF(ret);
 	    goto err;
 	}
 	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
+	// As we are not using copy_tv which increments reference count we must
-	 * do it ourself. */
+	// 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;
 }
 	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 */
+// 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))
 	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 */
+	VimTryEnd(); // Discard the error
 	Py_DECREF(path_hook);
 	return 0;
 }
 if (!(path = PySys_GetObject("path")))
 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 */
+	VimTryEnd(); // Discard the error
 }
 return 0;
 }

Mercurial > vim

comparison src/if_py_both.h @ 18753:6e3dc2d630c2 v8.1.2366