Problem: Using old C style comments.
Solution: Use // comments where appropriate.
*/
#include "vim.h"
-static pumitem_T *pum_array = NULL; /* items of displayed pum */
-static int pum_size; /* nr of items in "pum_array" */
-static int pum_selected; /* index of selected item or -1 */
-static int pum_first = 0; /* index of top item */
+static pumitem_T *pum_array = NULL; // items of displayed pum
+static int pum_size; // nr of items in "pum_array"
+static int pum_selected; // index of selected item or -1
+static int pum_first = 0; // index of top item
static int call_update_screen = FALSE;
-static int pum_height; /* nr of displayed pum items */
-static int pum_width; /* width of displayed pum items */
-static int pum_base_width; /* width of pum items base */
-static int pum_kind_width; /* width of pum items kind column */
-static int pum_extra_width; /* width of extra stuff */
-static int pum_scrollbar; /* TRUE when scrollbar present */
+static int pum_height; // nr of displayed pum items
+static int pum_width; // width of displayed pum items
+static int pum_base_width; // width of pum items base
+static int pum_kind_width; // width of pum items kind column
+static int pum_extra_width; // width of extra stuff
+static int pum_scrollbar; // TRUE when scrollbar present
-static int pum_row; /* top row of pum */
-static int pum_col; /* left column of pum */
+static int pum_row; // top row of pum
+static int pum_col; // left column of pum
static win_T *pum_window = NULL;
static int pum_win_row;
int i;
int w;
- /* Compute the width of the widest match and the widest extra. */
+ // Compute the width of the widest match and the widest extra.
pum_base_width = 0;
pum_kind_width = 0;
pum_extra_width = 0;
pum_display(
pumitem_T *array,
int size,
- int selected) /* index of initially selected item, none if
- out of range */
+ int selected) // index of initially selected item, none if
+ // out of range
{
int def_width;
int max_width;
above_row = 0;
below_row = cmdline_row;
- /* Pretend the pum is already there to avoid that must_redraw is set
- * when 'cuc' is on. */
+ // Pretend the pum is already there to avoid that must_redraw is set
+ // when 'cuc' is on.
pum_array = (pumitem_T *)1;
validate_cursor_col();
pum_array = NULL;
if (p_ph > 0 && pum_height > p_ph)
pum_height = p_ph;
- /* Put the pum below "pum_win_row" if possible. If there are few lines
- * decide on where there is more room. */
+ // Put the pum below "pum_win_row" if possible. If there are few lines
+ // decide on where there is more room.
if (pum_win_row + 2 >= below_row - pum_height
&& pum_win_row - above_row > (below_row - above_row) / 2)
{
- /* pum above "pum_win_row" */
+ // pum above "pum_win_row"
- /* Leave two lines of context if possible */
+ // Leave two lines of context if possible
if (curwin->w_wrow - curwin->w_cline_row >= 2)
context_lines = 2;
else
}
else
{
- /* pum below "pum_win_row" */
+ // pum below "pum_win_row"
- /* Leave two lines of context if possible */
+ // Leave two lines of context if possible
if (curwin->w_cline_row
+ curwin->w_cline_height - curwin->w_wrow >= 3)
context_lines = 3;
pum_height = p_ph;
}
- /* don't display when we only have room for one line */
+ // don't display when we only have room for one line
if (pum_height < 1 || (pum_height == 1 && size > 1))
return;
pum_compute_size();
max_width = pum_base_width;
- /* Calculate column */
+ // Calculate column
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl)
cursor_col = curwin->w_wincol + curwin->w_width
#endif
cursor_col = curwin->w_wincol + curwin->w_wcol;
- /* if there are more items than room we need a scrollbar */
+ // if there are more items than room we need a scrollbar
if (pum_height < size)
{
pum_scrollbar = 1;
#endif
))
{
- /* align pum with "cursor_col" */
+ // align pum with "cursor_col"
pum_col = cursor_col;
- /* start with the maximum space available */
+ // start with the maximum space available
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl)
pum_width = pum_col - pum_scrollbar + 1;
if (pum_width > max_width + pum_kind_width + pum_extra_width + 1
&& pum_width > p_pw)
{
- /* the width is more than needed for the items, make it
- * narrower */
+ // the width is more than needed for the items, make it
+ // narrower
pum_width = max_width + pum_kind_width + pum_extra_width + 1;
if (pum_width < p_pw)
pum_width = p_pw;
#endif
))
{
- /* align pum edge with "cursor_col" */
+ // align pum edge with "cursor_col"
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl
&& W_ENDCOL(curwin) < max_width + pum_scrollbar + 1)
if (curwin->w_wincol > Columns - max_width - pum_scrollbar
&& max_width <= p_pw)
{
- /* use full width to end of the screen */
+ // use full width to end of the screen
pum_col = Columns - max_width - pum_scrollbar;
if (pum_col < 0)
pum_col = 0;
}
else if (Columns < def_width)
{
- /* not enough room, will use what we have */
+ // not enough room, will use what we have
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl)
pum_col = Columns - 1;
else
{
if (max_width > p_pw)
- max_width = p_pw; /* truncate */
+ max_width = p_pw; // truncate
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl)
pum_col = max_width - 1;
pum_width = max_width - pum_scrollbar;
}
- /* Set selected item and redraw. If the window size changed need to
- * redo the positioning. Limit this to two times, when there is not
- * much room the window size will keep changing. */
+ // Set selected item and redraw. If the window size changed need to
+ // redo the positioning. Limit this to two times, when there is not
+ // much room the window size will keep changing.
} while (pum_set_selected(selected, redo_count) && ++redo_count <= 2);
}
idx = i + pum_first;
attr = (idx == pum_selected) ? attr_select : attr_norm;
- /* prepend a space if there is room */
+ // prepend a space if there is room
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl)
{
if (pum_col > 0)
screen_putchar(' ', row, pum_col - 1, attr);
- /* Display each entry, use two spaces for a Tab.
- * Do this 3 times: For the main text, kind and extra info */
+ // Display each entry, use two spaces for a Tab.
+ // Do this 3 times: For the main text, kind and extra info
col = pum_col;
totwidth = 0;
for (round = 1; round <= 3; ++round)
w = ptr2cells(p);
if (*p == NUL || *p == TAB || totwidth + w > pum_width)
{
- /* Display the text that fits or comes before a Tab.
- * First convert it to printable characters. */
+ // Display the text that fits or comes before a Tab.
+ // First convert it to printable characters.
char_u *st;
int saved = *p;
if (size < pum_width)
{
- /* Most left character requires
- * 2-cells but only 1 cell is
- * available on screen. Put a
- * '<' on the left of the pum
- * item */
+ // Most left character requires
+ // 2-cells but only 1 cell is
+ // available on screen. Put a
+ // '<' on the left of the pum
+ // item
*(--rt) = '<';
size++;
}
if (*p != TAB)
break;
- /* Display two spaces for a Tab. */
+ // Display two spaces for a Tab.
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl)
{
col += 2;
}
totwidth += 2;
- s = NULL; /* start text at next char */
+ s = NULL; // start text at next char
width = 0;
}
else
else
n = 1;
- /* Stop when there is nothing more to display. */
+ // Stop when there is nothing more to display.
if (round == 3
|| (round == 2 && pum_array[idx].pum_extra == NULL)
|| (round == 1 && pum_array[idx].pum_kind == NULL
{
if (pum_first > pum_selected - 4)
{
- /* scroll down; when we did a jump it's probably a PageUp then
- * scroll a whole page */
+ // scroll down; when we did a jump it's probably a PageUp then
+ // scroll a whole page
if (pum_first > pum_selected - 2)
{
pum_first -= pum_height - 2;
}
else if (pum_first < pum_selected - pum_height + 5)
{
- /* scroll up; when we did a jump it's probably a PageDown then
- * scroll a whole page */
+ // scroll up; when we did a jump it's probably a PageDown then
+ // scroll a whole page
if (pum_first < pum_selected - pum_height + 1 + 2)
{
pum_first += pum_height - 2;
pum_first = pum_selected - pum_height + 1;
}
- /* Give a few lines of context when possible. */
+ // Give a few lines of context when possible.
if (context > 3)
context = 3;
if (pum_height > 2)
{
if (pum_first > pum_selected - context)
{
- /* scroll down */
+ // scroll down
pum_first = pum_selected - context;
if (pum_first < 0)
pum_first = 0;
}
else if (pum_first < pum_selected + context - pum_height + 1)
{
- /* scroll up */
+ // scroll up
pum_first = pum_selected + context - pum_height + 1;
}
}
// delete the empty last line
ml_delete(curbuf->b_ml.ml_line_count, FALSE);
- /* Increase the height of the preview window to show the
- * text, but no more than 'previewheight' lines. */
+ // Increase the height of the preview window to show the
+ // text, but no more than 'previewheight' lines.
if (repeat == 0 && use_popup == USEPOPUP_NONE)
{
if (lnum > p_pvh)
if (curtab != curtab_save && valid_tabpage(curtab_save))
goto_tabpage_tp(curtab_save, FALSE, FALSE);
- /* When the first completion is done and the preview
- * window is not resized, skip the preview window's
- * status line redrawing. */
+ // When the first completion is done and the preview
+ // window is not resized, skip the preview window's
+ // status line redrawing.
if (ins_compl_active() && !resized)
curwin->w_redr_status = FALSE;
- /* Return cursor to where we were */
+ // Return cursor to where we were
validate_cursor();
redraw_later(SOME_VALID);
- /* When the preview window was resized we need to
- * update the view on the buffer. Only go back to
- * the window when needed, otherwise it will always be
- * redraw. */
+ // When the preview window was resized we need to
+ // update the view on the buffer. Only go back to
+ // the window when needed, otherwise it will always be
+ // redraw.
if (resized && win_valid(curwin_save))
{
++no_u_sync;
update_topline();
}
- /* Update the screen before drawing the popup menu.
- * Enable updating the status lines. */
+ // Update the screen before drawing the popup menu.
+ // Enable updating the status lines.
pum_do_redraw = TRUE;
update_screen(0);
pum_do_redraw = FALSE;
# endif
}
- /* May need to update the screen again when there are
- * autocommands involved. */
+ // May need to update the screen again when there are
+ // autocommands involved.
pum_do_redraw = TRUE;
update_screen(0);
pum_do_redraw = FALSE;
{
if (Rows - mouse_row > pum_size)
{
- /* Enough space below the mouse row. */
+ // Enough space below the mouse row.
pum_row = mouse_row + 1;
if (pum_height > Rows - pum_row)
pum_height = Rows - pum_row;
}
else
{
- /* Show above the mouse row, reduce height if it does not fit. */
+ // Show above the mouse row, reduce height if it does not fit.
pum_row = mouse_row - pum_size;
if (pum_row < 0)
{
}
if (Columns - mouse_col >= pum_base_width
|| Columns - mouse_col > min_width)
- /* Enough space to show at mouse column. */
+ // Enough space to show at mouse column.
pum_col = mouse_col;
else
- /* Not enough space, right align with window. */
+ // Not enough space, right align with window.
pum_col = Columns - (pum_base_width > min_width
? min_width : pum_base_width);
{
if ((*p == ',' && p[1] == ' ') || *p == '{' || *p == '}')
{
- /* Looks like a good point to break. */
+ // Looks like a good point to break.
if (*p == '{')
++indent;
else if (*p == '}' && indent > 0)
height = 2 + ga.ga_len;
- /* If there are long items and the height is below the limit: split lines */
+ // If there are long items and the height is below the limit: split lines
if (long_item_count > 0 && height + long_item_count <= max_height)
{
split_long_items = TRUE;
height += long_item_count;
}
- /* Limit to half the window height, it has to fit above or below the mouse
- * position. */
+ // Limit to half the window height, it has to fit above or below the mouse
+ // position.
if (height > max_height)
height = max_height;
*array = ALLOC_CLEAR_MULT(pumitem_T, height);
if (*array == NULL)
goto failed;
- /* Add an empty line above and below, looks better. */
+ // Add an empty line above and below, looks better.
(*array)->pum_text = vim_strsave((char_u *)"");
(*array + height - 1)->pum_text = vim_strsave((char_u *)"");
vim_strncpy(p + ind, item->start + skip, copylen);
(*array)[line].pum_text = p;
- item->indent = 0; /* wrapped line has no indent */
+ item->indent = 0; // wrapped line has no indent
++line;
}
}
pum_selected = -1;
pum_first = 0;
# ifdef FEAT_BEVAL_TERM
- p_bevalterm = TRUE; /* track mouse movement */
+ p_bevalterm = TRUE; // track mouse movement
mch_setmouse(TRUE);
# endif
break;
else if (c == CAR || c == NL)
{
- /* enter: select current item, if any, and close */
+ // enter: select current item, if any, and close
pum_execute_menu(menu, mode);
break;
}
else if (c == 'k' || c == K_UP || c == K_MOUSEUP)
{
- /* cursor up: select previous item */
+ // cursor up: select previous item
while (pum_selected > 0)
{
--pum_selected;
}
else if (c == 'j' || c == K_DOWN || c == K_MOUSEDOWN)
{
- /* cursor down: select next item */
+ // cursor down: select next item
while (pum_selected < pum_size - 1)
{
++pum_selected;
}
else if (c == K_RIGHTMOUSE)
{
- /* Right mouse down: reposition the menu. */
+ // Right mouse down: reposition the menu.
vungetc(c);
break;
}
else if (c == K_LEFTDRAG || c == K_RIGHTDRAG || c == K_MOUSEMOVE)
{
- /* mouse moved: select item in the mouse row */
+ // mouse moved: select item in the mouse row
pum_select_mouse_pos();
}
else if (c == K_LEFTMOUSE || c == K_LEFTMOUSE_NM || c == K_RIGHTRELEASE)
{
- /* left mouse click: select clicked item, if any, and close;
- * right mouse release: select clicked item, close if any */
+ // left mouse click: select clicked item, if any, and close;
+ // right mouse release: select clicked item, close if any
pum_select_mouse_pos();
if (pum_selected >= 0)
{
if (!use_mouse_pos)
{
- /* Hack: set mouse position at the cursor so that the menu pops up
- * around there. */
+ // Hack: set mouse position at the cursor so that the menu pops up
+ // around there.
mouse_row = curwin->w_winrow + curwin->w_wrow;
mouse_col = curwin->w_wincol + curwin->w_wcol;
}
* copyright notice below.
*/
-/* Copyright (c) 1993
- * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
- * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
- * Copyright (c) 1987 Oliver Laumann
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program (see the file COPYING); if not, write to the
- * Free Software Foundation, Inc.,
- * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
+// Copyright (c) 1993
+// Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
+// Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
+// Copyright (c) 1987 Oliver Laumann
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program (see the file COPYING); if not, write to the
+// Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
#include "vim.h"
# define PTYRANGE1 "0123456789abcdef"
#endif
-/* SVR4 pseudo ttys don't seem to work with SCO-5 */
+// SVR4 pseudo ttys don't seem to work with SCO-5
#ifdef M_UNIX
# undef HAVE_SVR4_PTYS
#endif
{
char *m, *s;
int f;
- /* used for opening a new pty-pair: */
+ // used for opening a new pty-pair:
static char PtyName[32];
static char TtyName[32];
{
int f;
stat_T buf;
- /* used for opening a new pty-pair: */
+ // used for opening a new pty-pair:
static char TtyName[32];
if ((f = open("/dev/ptc", O_RDWR | O_NOCTTY | O_NONBLOCK | O_EXTRA, 0)) < 0)
#if defined(HAVE_SVR4_PTYS) && !defined(PTY_DONE) && !defined(hpux) \
&& !(defined(MACOS_X) && !defined(MAC_OS_X_VERSION_10_6))
-/* NOTE: Even though HPUX can have /dev/ptmx, the code below doesn't work!
- * Same for Mac OS X Leopard (10.5). */
+// NOTE: Even though HPUX can have /dev/ptmx, the code below doesn't work!
+// Same for Mac OS X Leopard (10.5).
#define PTY_DONE
int
mch_openpty(char **ttyn)
int f;
char *m;
RETSIGTYPE (*sigcld) SIGPROTOARG;
- /* used for opening a new pty-pair: */
+ // used for opening a new pty-pair:
static char TtyName[32];
if ((f = open("/dev/ptmx", O_RDWR | O_NOCTTY | O_EXTRA, 0)) == -1)
mch_openpty(char **ttyn)
{
int f;
- /* used for opening a new pty-pair: */
+ // used for opening a new pty-pair:
static char TtyName[32];
- /* a dumb looking loop replaced by mycrofts code: */
+ // a dumb looking loop replaced by mycrofts code:
if ((f = open("/dev/ptc", O_RDWR | O_NOCTTY | O_EXTRA)) < 0)
return -1;
vim_strncpy((char_u *)TtyName, (char_u *)ttyname(f), sizeof(TtyName) - 1);
{
char *p, *q, *l, *d;
int f;
- /* used for opening a new pty-pair: */
+ // used for opening a new pty-pair:
static char PtyName[32];
static char TtyName[32];
continue;
}
#if defined(SUN_SYSTEM) && defined(TIOCGPGRP) && !defined(SUNOS3)
- /* Hack to ensure that the slave side of the pty is
- * unused. May not work in anything other than SunOS4.1
- */
+ // Hack to ensure that the slave side of the pty is
+ // unused. May not work in anything other than SunOS4.1
{
int pgrp;
- /* tcgetpgrp does not work (uses TIOCGETPGRP)! */
+ // tcgetpgrp does not work (uses TIOCGETPGRP)!
if (ioctl(f, TIOCGPGRP, (char *)&pgrp) != -1 || errno != EIO)
{
close(f);
return isatty(fd);
}
-#endif /* FEAT_GUI || FEAT_JOB_CHANNEL */
+#endif // FEAT_GUI || FEAT_JOB_CHANNEL
curwin->w_llist = qi;
}
}
-#endif /* FEAT_QUICKFIX */
+#endif // FEAT_QUICKFIX
#if defined(FEAT_EVAL) || defined(PROTO)
# ifdef FEAT_QUICKFIX
#include "vim.h"
#ifdef DEBUG
-/* show/save debugging data when BT engine is used */
+// show/save debugging data when BT engine is used
# define BT_REGEXP_DUMP
-/* save the debugging data to a file instead of displaying it */
+// save the debugging data to a file instead of displaying it
# define BT_REGEXP_LOG
# define BT_REGEXP_DEBUG_LOG
# define BT_REGEXP_DEBUG_LOG_NAME "bt_regexp_debug.log"
*/
#define UCHARAT(p) ((int)*(char_u *)(p))
-/* Used for an error (down from) vim_regcomp(): give the error message, set
- * rc_did_emsg and return NULL */
+// Used for an error (down from) vim_regcomp(): give the error message, set
+// rc_did_emsg and return NULL
#define EMSG_RET_NULL(m) return (emsg((m)), rc_did_emsg = TRUE, (void *)NULL)
#define IEMSG_RET_NULL(m) return (iemsg((m)), rc_did_emsg = TRUE, (void *)NULL)
#define EMSG_RET_FAIL(m) return (emsg((m)), rc_did_emsg = TRUE, FAIL)
#define MULTI_MULT 2
// return values for regmatch()
-#define RA_FAIL 1 /* something failed, abort */
-#define RA_CONT 2 /* continue in inner loop */
-#define RA_BREAK 3 /* break inner loop */
-#define RA_MATCH 4 /* successful match */
-#define RA_NOMATCH 5 /* didn't match */
+#define RA_FAIL 1 // something failed, abort
+#define RA_CONT 2 // continue in inner loop
+#define RA_BREAK 3 // break inner loop
+#define RA_MATCH 4 // successful match
+#define RA_NOMATCH 5 // didn't match
/*
* Return NOT_MULTI if c is not a "multi" operator.
#define ri_upper(c) (c < 0x100 && (class_tab[c] & RI_UPPER))
#define ri_white(c) (c < 0x100 && (class_tab[c] & RI_WHITE))
-/* flags for regflags */
-#define RF_ICASE 1 /* ignore case */
-#define RF_NOICASE 2 /* don't ignore case */
-#define RF_HASNL 4 /* can match a NL */
-#define RF_ICOMBINE 8 /* ignore combining characters */
-#define RF_LOOKBH 16 /* uses "\@<=" or "\@<!" */
+// flags for regflags
+#define RF_ICASE 1 // ignore case
+#define RF_NOICASE 2 // don't ignore case
+#define RF_HASNL 4 // can match a NL
+#define RF_ICOMBINE 8 // ignore combining characters
+#define RF_LOOKBH 16 // uses "\@<=" or "\@<!"
/*
* Global work variables for vim_regcomp().
*/
-static char_u *regparse; /* Input-scan pointer. */
-static int regnpar; /* () count. */
+static char_u *regparse; // Input-scan pointer.
+static int regnpar; // () count.
#ifdef FEAT_SYN_HL
-static int regnzpar; /* \z() count. */
-static int re_has_z; /* \z item detected */
+static int regnzpar; // \z() count.
+static int re_has_z; // \z item detected
#endif
-static unsigned regflags; /* RF_ flags for prog */
+static unsigned regflags; // RF_ flags for prog
#if defined(FEAT_SYN_HL) || defined(PROTO)
-static int had_eol; /* TRUE when EOL found by vim_regcomp() */
+static int had_eol; // TRUE when EOL found by vim_regcomp()
#endif
-static int reg_magic; /* magicness of the pattern: */
-#define MAGIC_NONE 1 /* "\V" very unmagic */
-#define MAGIC_OFF 2 /* "\M" or 'magic' off */
-#define MAGIC_ON 3 /* "\m" or 'magic' */
-#define MAGIC_ALL 4 /* "\v" very magic */
+static int reg_magic; // magicness of the pattern:
+#define MAGIC_NONE 1 // "\V" very unmagic
+#define MAGIC_OFF 2 // "\M" or 'magic' off
+#define MAGIC_ON 3 // "\m" or 'magic'
+#define MAGIC_ALL 4 // "\v" very magic
-static int reg_string; /* matching with a string instead of a buffer
- line */
-static int reg_strict; /* "[abc" is illegal */
+static int reg_string; // matching with a string instead of a buffer
+ // line
+static int reg_strict; // "[abc" is illegal
/*
* META contains all characters that may be magic, except '^' and '$'.
#ifdef EBCDIC
static char_u META[] = "%&()*+.123456789<=>?@ACDFHIKLMOPSUVWX[_acdfhiklmnopsuvwxz{|~";
#else
-/* META[] is used often enough to justify turning it into a table. */
+// META[] is used often enough to justify turning it into a table.
static char_u META_flags[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* % & ( ) * + . */
+// % & ( ) * + .
0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0,
-/* 1 2 3 4 5 6 7 8 9 < = > ? */
+// 1 2 3 4 5 6 7 8 9 < = > ?
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,
-/* @ A C D F H I K L M O */
+// @ A C D F H I K L M O
1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,
-/* P S U V W X Z [ _ */
+// P S U V W X Z [ _
1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1,
-/* a c d f h i k l m n o */
+// a c d f h i k l m n o
0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1,
-/* p s u v w x z { | ~ */
+// p s u v w x z { | ~
1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1
};
#endif
-static int curchr; /* currently parsed character */
-/* Previous character. Note: prevchr is sometimes -1 when we are not at the
- * start, eg in /[ ^I]^ the pattern was never found even if it existed,
- * because ^ was taken to be magic -- webb */
+static int curchr; // currently parsed character
+// Previous character. Note: prevchr is sometimes -1 when we are not at the
+// start, eg in /[ ^I]^ the pattern was never found even if it existed,
+// because ^ was taken to be magic -- webb
static int prevchr;
-static int prevprevchr; /* previous-previous character */
-static int nextchr; /* used for ungetchr() */
+static int prevprevchr; // previous-previous character
+static int nextchr; // used for ungetchr()
-/* arguments for reg() */
-#define REG_NOPAREN 0 /* toplevel reg() */
-#define REG_PAREN 1 /* \(\) */
-#define REG_ZPAREN 2 /* \z(\) */
-#define REG_NPAREN 3 /* \%(\) */
+// arguments for reg()
+#define REG_NOPAREN 0 // toplevel reg()
+#define REG_PAREN 1 // \(\)
+#define REG_ZPAREN 2 // \z(\)
+#define REG_NPAREN 3 // \%(\)
typedef struct
{
return 0;
}
-static int reg_cpo_lit; /* 'cpoptions' contains 'l' flag */
-static int reg_cpo_bsl; /* 'cpoptions' contains '\' flag */
+static int reg_cpo_lit; // 'cpoptions' contains 'l' flag
+static int reg_cpo_bsl; // 'cpoptions' contains '\' flag
static void
get_cpo_flags(void)
{
int l;
- if (*p == '^') /* Complement of range. */
+ if (*p == '^') // Complement of range.
++p;
if (*p == ']' || *p == '-')
++p;
&& get_equi_class(&p) == 0
&& get_coll_element(&p) == 0
&& *p != NUL)
- ++p; /* it is not a class name and not NUL */
+ ++p; // it is not a class name and not NUL
}
else
++p;
for (; p[0] != NUL; MB_PTR_ADV(p))
{
- if (p[0] == dirc) /* found end of regexp */
+ if (p[0] == dirc) // found end of regexp
break;
if ((p[0] == '[' && mymagic >= MAGIC_ON)
|| (p[0] == '\\' && p[1] == '[' && mymagic <= MAGIC_OFF))
{
if (dirc == '?' && newp != NULL && p[1] == '?')
{
- /* change "\?" to "?", make a copy first. */
+ // change "\?" to "?", make a copy first.
if (*newp == NULL)
{
*newp = vim_strsave(startp);
++p;
}
else
- ++p; /* skip next character */
+ ++p; // skip next character
if (*p == 'v')
mymagic = MAGIC_ALL;
else if (*p == 'V')
/*
* Functions for getting characters from the regexp input.
*/
-static int prevchr_len; /* byte length of previous char */
+static int prevchr_len; // byte length of previous char
static int at_start; // True when on the first character
static int prev_at_start; // True when on the second character
case '.':
case '[':
case '~':
- /* magic when 'magic' is on */
+ // magic when 'magic' is on
if (reg_magic >= MAGIC_ON)
curchr = Magic(curchr);
break;
case '|':
case '<':
case '>':
- case '#': /* future ext. */
- case '"': /* future ext. */
- case '\'': /* future ext. */
- case ',': /* future ext. */
- case '-': /* future ext. */
- case ':': /* future ext. */
- case ';': /* future ext. */
- case '`': /* future ext. */
- case '/': /* Can't be used in / command */
- /* magic only after "\v" */
+ case '#': // future ext.
+ case '"': // future ext.
+ case '\'': // future ext.
+ case ',': // future ext.
+ case '-': // future ext.
+ case ':': // future ext.
+ case ';': // future ext.
+ case '`': // future ext.
+ case '/': // Can't be used in / command
+ // magic only after "\v"
if (reg_magic == MAGIC_ALL)
curchr = Magic(curchr);
break;
case '*':
- /* * is not magic as the very first character, eg "?*ptr", when
- * after '^', eg "/^*ptr" and when after "\(", "\|", "\&". But
- * "\(\*" is not magic, thus must be magic if "after_slash" */
+ // * is not magic as the very first character, eg "?*ptr", when
+ // after '^', eg "/^*ptr" and when after "\(", "\|", "\&". But
+ // "\(\*" is not magic, thus must be magic if "after_slash"
if (reg_magic >= MAGIC_ON
&& !at_start
&& !(prev_at_start && prevchr == Magic('^'))
curchr = Magic('*');
break;
case '^':
- /* '^' is only magic as the very first character and if it's after
- * "\(", "\|", "\&' or "\n" */
+ // '^' is only magic as the very first character and if it's after
+ // "\(", "\|", "\&' or "\n"
if (reg_magic >= MAGIC_OFF
&& (at_start
|| reg_magic == MAGIC_ALL
}
break;
case '$':
- /* '$' is only magic as the very last char and if it's in front of
- * either "\|", "\)", "\&", or "\n" */
+ // '$' is only magic as the very last char and if it's in front of
+ // either "\|", "\)", "\&", or "\n"
if (reg_magic >= MAGIC_OFF)
{
char_u *p = regparse + 1;
int is_magic_all = (reg_magic == MAGIC_ALL);
- /* ignore \c \C \m \M \v \V and \Z after '$' */
+ // ignore \c \C \m \M \v \V and \Z after '$'
while (p[0] == '\\' && (p[1] == 'c' || p[1] == 'C'
|| p[1] == 'm' || p[1] == 'M'
|| p[1] == 'v' || p[1] == 'V' || p[1] == 'Z'))
int c = regparse[1];
if (c == NUL)
- curchr = '\\'; /* trailing '\' */
+ curchr = '\\'; // trailing '\'
else if (
#ifdef EBCDIC
vim_strchr(META, c)
*/
curchr = -1;
prev_at_start = at_start;
- at_start = FALSE; /* be able to say "/\*ptr" */
+ at_start = FALSE; // be able to say "/\*ptr"
++regparse;
++after_slash;
peekchr();
static void
skipchr(void)
{
- /* peekchr() eats a backslash, do the same here */
+ // peekchr() eats a backslash, do the same here
if (*regparse == '\\')
prevchr_len = 1;
else
if (regparse[prevchr_len] != NUL)
{
if (enc_utf8)
- /* exclude composing chars that mb_ptr2len does include */
+ // exclude composing chars that mb_ptr2len does include
prevchr_len += utf_ptr2len(regparse + prevchr_len);
else if (has_mbyte)
prevchr_len += (*mb_ptr2len)(regparse + prevchr_len);
at_start = FALSE;
prevprevchr = prevchr;
prevchr = curchr;
- curchr = nextchr; /* use previously unget char, or -1 */
+ curchr = nextchr; // use previously unget char, or -1
nextchr = -1;
}
at_start = prev_at_start;
prev_at_start = FALSE;
- /* Backup regparse, so that it's at the same position as before the
- * getchr(). */
+ // Backup regparse, so that it's at the same position as before the
+ // getchr().
regparse -= prevchr_len;
}
nr *= 10;
nr += c - '0';
++regparse;
- curchr = -1; /* no longer valid */
+ curchr = -1; // no longer valid
}
if (i == 0)
if (*regparse == '-')
{
- /* Starts with '-', so reverse the range later */
+ // Starts with '-', so reverse the range later
regparse++;
reverse = TRUE;
}
first_char = regparse;
*minval = getdigits(®parse);
- if (*regparse == ',') /* There is a comma */
+ if (*regparse == ',') // There is a comma
{
if (vim_isdigit(*++regparse))
*maxval = getdigits(®parse);
*maxval = MAX_LIMIT;
}
else if (VIM_ISDIGIT(*first_char))
- *maxval = *minval; /* It was \{n} or \{-n} */
+ *maxval = *minval; // It was \{n} or \{-n}
else
- *maxval = MAX_LIMIT; /* It was \{} or \{-} */
+ *maxval = MAX_LIMIT; // It was \{} or \{-}
if (*regparse == '\\')
- regparse++; /* Allow either \{...} or \{...\} */
+ regparse++; // Allow either \{...} or \{...\}
if (*regparse != '}')
EMSG2_RET_FAIL(_("E554: Syntax error in %s{...}"),
reg_magic == MAGIC_ALL);
*minval = *maxval;
*maxval = tmp;
}
- skipchr(); /* let's be friends with the lexer again */
+ skipchr(); // let's be friends with the lexer again
return OK;
}
buf_T *reg_buf;
linenr_T reg_firstlnum;
linenr_T reg_maxline;
- int reg_line_lbr; /* "\n" in string is line break */
+ int reg_line_lbr; // "\n" in string is line break
// The current match-position is stord in these variables:
linenr_T lnum; // line number, relative to first line
// cleared
#endif
- /* Internal copy of 'ignorecase'. It is set at each call to vim_regexec().
- * Normally it gets the value of "rm_ic" or "rmm_ic", but when the pattern
- * contains '\c' or '\C' the value is overruled. */
+ // Internal copy of 'ignorecase'. It is set at each call to vim_regexec().
+ // Normally it gets the value of "rm_ic" or "rmm_ic", but when the pattern
+ // contains '\c' or '\C' the value is overruled.
int reg_ic;
- /* Similar to "reg_ic", but only for 'combining' characters. Set with \Z
- * flag in the regexp. Defaults to false, always. */
+ // Similar to "reg_ic", but only for 'combining' characters. Set with \Z
+ // flag in the regexp. Defaults to false, always.
int reg_icombine;
- /* Copy of "rmm_maxcol": maximum column to search for a match. Zero when
- * there is no maximum. */
+ // Copy of "rmm_maxcol": maximum column to search for a match. Zero when
+ // there is no maximum.
colnr_T reg_maxcol;
// State for the NFA engine regexec.
static char_u *
reg_getline(linenr_T lnum)
{
- /* when looking behind for a match/no-match lnum is negative. But we
- * can't go before line 1 */
+ // when looking behind for a match/no-match lnum is negative. But we
+ // can't go before line 1
if (rex.reg_firstlnum + lnum < 1)
return NULL;
if (lnum > rex.reg_maxline)
- /* Must have matched the "\n" in the last line. */
+ // Must have matched the "\n" in the last line.
return (char_u *)"";
return ml_get_buf(rex.reg_buf, rex.reg_firstlnum + lnum, FALSE);
}
#ifdef FEAT_SYN_HL
-static char_u *reg_startzp[NSUBEXP]; /* Workspace to mark beginning */
-static char_u *reg_endzp[NSUBEXP]; /* and end of \z(...\) matches */
-static lpos_T reg_startzpos[NSUBEXP]; /* idem, beginning pos */
-static lpos_T reg_endzpos[NSUBEXP]; /* idem, end pos */
+static char_u *reg_startzp[NSUBEXP]; // Workspace to mark beginning
+static char_u *reg_endzp[NSUBEXP]; // and end of \z(...\) matches
+static lpos_T reg_startzpos[NSUBEXP]; // idem, beginning pos
+static lpos_T reg_endzpos[NSUBEXP]; // idem, end pos
#endif
-/* TRUE if using multi-line regexp. */
+// TRUE if using multi-line regexp.
#define REG_MULTI (rex.reg_match == NULL)
#ifdef FEAT_SYN_HL
colnr_T start2, end2;
colnr_T cols;
- /* Check if the buffer is the current buffer. */
+ // Check if the buffer is the current buffer.
if (rex.reg_buf != curbuf || VIsual.lnum == 0)
return FALSE;
prog = REG_MULTI ? rex.reg_mmatch->regprog : rex.reg_match->regprog;
if (prog->engine == &nfa_regengine)
- /* For NFA matcher we don't check the magic */
+ // For NFA matcher we don't check the magic
return FALSE;
if (UCHARAT(((bt_regprog_T *)prog)->program) != REGMAGIC)
{
if (REG_MULTI)
{
- /* Use 0xff to set lnum to -1 */
+ // Use 0xff to set lnum to -1
vim_memset(rex.reg_startpos, 0xff, sizeof(lpos_T) * NSUBEXP);
vim_memset(rex.reg_endpos, 0xff, sizeof(lpos_T) * NSUBEXP);
}
{
if (REG_MULTI)
{
- /* Use 0xff to set lnum to -1 */
+ // Use 0xff to set lnum to -1
vim_memset(reg_startzpos, 0xff, sizeof(lpos_T) * NSUBEXP);
vim_memset(reg_endzpos, 0xff, sizeof(lpos_T) * NSUBEXP);
}
*bytelen = 0;
for (;;)
{
- /* Since getting one line may invalidate the other, need to make copy.
- * Slow! */
+ // Since getting one line may invalidate the other, need to make copy.
+ // Slow!
if (rex.line != reg_tofree)
{
len = (int)STRLEN(rex.line);
if (reg_tofree == NULL || len >= (int)reg_tofreelen)
{
- len += 50; /* get some extra */
+ len += 50; // get some extra
vim_free(reg_tofree);
reg_tofree = alloc(len);
if (reg_tofree == NULL)
- return RA_FAIL; /* out of memory!*/
+ return RA_FAIL; // out of memory!
reg_tofreelen = len;
}
STRCPY(reg_tofree, rex.line);
rex.line = reg_tofree;
}
- /* Get the line to compare with. */
+ // Get the line to compare with.
p = reg_getline(clnum);
if (clnum == end_lnum)
len = end_col - ccol;
len = (int)STRLEN(p + ccol);
if (cstrncmp(p + ccol, rex.input, &len) != 0)
- return RA_NOMATCH; /* doesn't match */
+ return RA_NOMATCH; // doesn't match
if (bytelen != NULL)
*bytelen += len;
if (clnum == end_lnum)
- break; /* match and at end! */
+ break; // match and at end!
if (rex.lnum >= rex.reg_maxline)
- return RA_NOMATCH; /* text too short */
+ return RA_NOMATCH; // text too short
- /* Advance to next line. */
+ // Advance to next line.
reg_nextline();
if (bytelen != NULL)
*bytelen = 0;
return RA_FAIL;
}
- /* found a match! Note that rex.line may now point to a copy of the line,
- * that should not matter. */
+ // found a match! Note that rex.line may now point to a copy of the line,
+ // that should not matter.
return RA_MATCH;
}
} decomp_T;
-/* 0xfb20 - 0xfb4f */
+// 0xfb20 - 0xfb4f
static decomp_T decomp_table[0xfb4f-0xfb20+1] =
{
- {0x5e2,0,0}, /* 0xfb20 alt ayin */
- {0x5d0,0,0}, /* 0xfb21 alt alef */
- {0x5d3,0,0}, /* 0xfb22 alt dalet */
- {0x5d4,0,0}, /* 0xfb23 alt he */
- {0x5db,0,0}, /* 0xfb24 alt kaf */
- {0x5dc,0,0}, /* 0xfb25 alt lamed */
- {0x5dd,0,0}, /* 0xfb26 alt mem-sofit */
- {0x5e8,0,0}, /* 0xfb27 alt resh */
- {0x5ea,0,0}, /* 0xfb28 alt tav */
- {'+', 0, 0}, /* 0xfb29 alt plus */
- {0x5e9, 0x5c1, 0}, /* 0xfb2a shin+shin-dot */
- {0x5e9, 0x5c2, 0}, /* 0xfb2b shin+sin-dot */
- {0x5e9, 0x5c1, 0x5bc}, /* 0xfb2c shin+shin-dot+dagesh */
- {0x5e9, 0x5c2, 0x5bc}, /* 0xfb2d shin+sin-dot+dagesh */
- {0x5d0, 0x5b7, 0}, /* 0xfb2e alef+patah */
- {0x5d0, 0x5b8, 0}, /* 0xfb2f alef+qamats */
- {0x5d0, 0x5b4, 0}, /* 0xfb30 alef+hiriq */
- {0x5d1, 0x5bc, 0}, /* 0xfb31 bet+dagesh */
- {0x5d2, 0x5bc, 0}, /* 0xfb32 gimel+dagesh */
- {0x5d3, 0x5bc, 0}, /* 0xfb33 dalet+dagesh */
- {0x5d4, 0x5bc, 0}, /* 0xfb34 he+dagesh */
- {0x5d5, 0x5bc, 0}, /* 0xfb35 vav+dagesh */
- {0x5d6, 0x5bc, 0}, /* 0xfb36 zayin+dagesh */
- {0xfb37, 0, 0}, /* 0xfb37 -- UNUSED */
- {0x5d8, 0x5bc, 0}, /* 0xfb38 tet+dagesh */
- {0x5d9, 0x5bc, 0}, /* 0xfb39 yud+dagesh */
- {0x5da, 0x5bc, 0}, /* 0xfb3a kaf sofit+dagesh */
- {0x5db, 0x5bc, 0}, /* 0xfb3b kaf+dagesh */
- {0x5dc, 0x5bc, 0}, /* 0xfb3c lamed+dagesh */
- {0xfb3d, 0, 0}, /* 0xfb3d -- UNUSED */
- {0x5de, 0x5bc, 0}, /* 0xfb3e mem+dagesh */
- {0xfb3f, 0, 0}, /* 0xfb3f -- UNUSED */
- {0x5e0, 0x5bc, 0}, /* 0xfb40 nun+dagesh */
- {0x5e1, 0x5bc, 0}, /* 0xfb41 samech+dagesh */
- {0xfb42, 0, 0}, /* 0xfb42 -- UNUSED */
- {0x5e3, 0x5bc, 0}, /* 0xfb43 pe sofit+dagesh */
- {0x5e4, 0x5bc,0}, /* 0xfb44 pe+dagesh */
- {0xfb45, 0, 0}, /* 0xfb45 -- UNUSED */
- {0x5e6, 0x5bc, 0}, /* 0xfb46 tsadi+dagesh */
- {0x5e7, 0x5bc, 0}, /* 0xfb47 qof+dagesh */
- {0x5e8, 0x5bc, 0}, /* 0xfb48 resh+dagesh */
- {0x5e9, 0x5bc, 0}, /* 0xfb49 shin+dagesh */
- {0x5ea, 0x5bc, 0}, /* 0xfb4a tav+dagesh */
- {0x5d5, 0x5b9, 0}, /* 0xfb4b vav+holam */
- {0x5d1, 0x5bf, 0}, /* 0xfb4c bet+rafe */
- {0x5db, 0x5bf, 0}, /* 0xfb4d kaf+rafe */
- {0x5e4, 0x5bf, 0}, /* 0xfb4e pe+rafe */
- {0x5d0, 0x5dc, 0} /* 0xfb4f alef-lamed */
+ {0x5e2,0,0}, // 0xfb20 alt ayin
+ {0x5d0,0,0}, // 0xfb21 alt alef
+ {0x5d3,0,0}, // 0xfb22 alt dalet
+ {0x5d4,0,0}, // 0xfb23 alt he
+ {0x5db,0,0}, // 0xfb24 alt kaf
+ {0x5dc,0,0}, // 0xfb25 alt lamed
+ {0x5dd,0,0}, // 0xfb26 alt mem-sofit
+ {0x5e8,0,0}, // 0xfb27 alt resh
+ {0x5ea,0,0}, // 0xfb28 alt tav
+ {'+', 0, 0}, // 0xfb29 alt plus
+ {0x5e9, 0x5c1, 0}, // 0xfb2a shin+shin-dot
+ {0x5e9, 0x5c2, 0}, // 0xfb2b shin+sin-dot
+ {0x5e9, 0x5c1, 0x5bc}, // 0xfb2c shin+shin-dot+dagesh
+ {0x5e9, 0x5c2, 0x5bc}, // 0xfb2d shin+sin-dot+dagesh
+ {0x5d0, 0x5b7, 0}, // 0xfb2e alef+patah
+ {0x5d0, 0x5b8, 0}, // 0xfb2f alef+qamats
+ {0x5d0, 0x5b4, 0}, // 0xfb30 alef+hiriq
+ {0x5d1, 0x5bc, 0}, // 0xfb31 bet+dagesh
+ {0x5d2, 0x5bc, 0}, // 0xfb32 gimel+dagesh
+ {0x5d3, 0x5bc, 0}, // 0xfb33 dalet+dagesh
+ {0x5d4, 0x5bc, 0}, // 0xfb34 he+dagesh
+ {0x5d5, 0x5bc, 0}, // 0xfb35 vav+dagesh
+ {0x5d6, 0x5bc, 0}, // 0xfb36 zayin+dagesh
+ {0xfb37, 0, 0}, // 0xfb37 -- UNUSED
+ {0x5d8, 0x5bc, 0}, // 0xfb38 tet+dagesh
+ {0x5d9, 0x5bc, 0}, // 0xfb39 yud+dagesh
+ {0x5da, 0x5bc, 0}, // 0xfb3a kaf sofit+dagesh
+ {0x5db, 0x5bc, 0}, // 0xfb3b kaf+dagesh
+ {0x5dc, 0x5bc, 0}, // 0xfb3c lamed+dagesh
+ {0xfb3d, 0, 0}, // 0xfb3d -- UNUSED
+ {0x5de, 0x5bc, 0}, // 0xfb3e mem+dagesh
+ {0xfb3f, 0, 0}, // 0xfb3f -- UNUSED
+ {0x5e0, 0x5bc, 0}, // 0xfb40 nun+dagesh
+ {0x5e1, 0x5bc, 0}, // 0xfb41 samech+dagesh
+ {0xfb42, 0, 0}, // 0xfb42 -- UNUSED
+ {0x5e3, 0x5bc, 0}, // 0xfb43 pe sofit+dagesh
+ {0x5e4, 0x5bc,0}, // 0xfb44 pe+dagesh
+ {0xfb45, 0, 0}, // 0xfb45 -- UNUSED
+ {0x5e6, 0x5bc, 0}, // 0xfb46 tsadi+dagesh
+ {0x5e7, 0x5bc, 0}, // 0xfb47 qof+dagesh
+ {0x5e8, 0x5bc, 0}, // 0xfb48 resh+dagesh
+ {0x5e9, 0x5bc, 0}, // 0xfb49 shin+dagesh
+ {0x5ea, 0x5bc, 0}, // 0xfb4a tav+dagesh
+ {0x5d5, 0x5b9, 0}, // 0xfb4b vav+holam
+ {0x5d1, 0x5bf, 0}, // 0xfb4c bet+rafe
+ {0x5db, 0x5bf, 0}, // 0xfb4d kaf+rafe
+ {0x5e4, 0x5bf, 0}, // 0xfb4e pe+rafe
+ {0x5d0, 0x5dc, 0} // 0xfb4f alef-lamed
};
static void
else
result = MB_STRNICMP(s1, s2, *n);
- /* if it failed and it's utf8 and we want to combineignore: */
+ // if it failed and it's utf8 and we want to combineignore:
if (result != 0 && enc_utf8 && rex.reg_icombine)
{
char_u *str1, *str2;
int c1, c2, c11, c12;
int junk;
- /* we have to handle the strcmp ourselves, since it is necessary to
- * deal with the composing characters by ignoring them: */
+ // we have to handle the strcmp ourselves, since it is necessary to
+ // deal with the composing characters by ignoring them:
str1 = s1;
str2 = s2;
c1 = c2 = 0;
if (!rex.reg_ic || (!enc_utf8 && mb_char2len(c) > 1))
return vim_strchr(s, c);
- /* tolower() and toupper() can be slow, comparing twice should be a lot
- * faster (esp. when using MS Visual C++!).
- * For UTF-8 need to use folded case. */
+ // tolower() and toupper() can be slow, comparing twice should be a lot
+ // faster (esp. when using MS Visual C++!).
+ // For UTF-8 need to use folded case.
if (enc_utf8 && c > 0x80)
cc = utf_fold(c);
else
}
}
else
- /* Faster version for when there are no multi-byte characters. */
+ // Faster version for when there are no multi-byte characters.
for (p = s; *p != NUL; ++p)
if (*p == c || *p == cc)
return p;
return NULL;
}
-/***************************************************************
- * regsub stuff *
- ***************************************************************/
+////////////////////////////////////////////////////////////////
+// regsub stuff //
+////////////////////////////////////////////////////////////////
/*
* We should define ftpr as a pointer to a function returning a pointer to
{
if (reg_prev_sub != NULL)
{
- /* length = len(newsub) - 1 + len(prev_sub) + 1 */
+ // length = len(newsub) - 1 + len(prev_sub) + 1
prevlen = (int)STRLEN(reg_prev_sub);
tmpsub = alloc(STRLEN(newsub) + prevlen);
if (tmpsub != NULL)
{
- /* copy prefix */
- len = (int)(p - newsub); /* not including ~ */
+ // copy prefix
+ len = (int)(p - newsub); // not including ~
mch_memmove(tmpsub, newsub, (size_t)len);
- /* interpret tilde */
+ // interpret tilde
mch_memmove(tmpsub + len, reg_prev_sub, (size_t)prevlen);
- /* copy postfix */
+ // copy postfix
if (!magic)
- ++p; /* back off \ */
+ ++p; // back off backslash
STRCPY(tmpsub + len + prevlen, p + 1);
- if (newsub != source) /* already allocated newsub */
+ if (newsub != source) // already allocated newsub
vim_free(newsub);
newsub = tmpsub;
p = newsub + len + prevlen;
}
}
else if (magic)
- STRMOVE(p, p + 1); /* remove '~' */
+ STRMOVE(p, p + 1); // remove '~'
else
- STRMOVE(p, p + 2); /* remove '\~' */
+ STRMOVE(p, p + 2); // remove '\~'
--p;
}
else
{
- if (*p == '\\' && p[1]) /* skip escaped characters */
+ if (*p == '\\' && p[1]) // skip escaped characters
++p;
if (has_mbyte)
p += (*mb_ptr2len)(p) - 1;
}
vim_free(reg_prev_sub);
- if (newsub != source) /* newsub was allocated, just keep it */
+ if (newsub != source) // newsub was allocated, just keep it
reg_prev_sub = newsub;
- else /* no ~ found, need to save newsub */
+ else // no ~ found, need to save newsub
reg_prev_sub = vim_strsave(newsub);
return newsub;
}
#ifdef FEAT_EVAL
-static int can_f_submatch = FALSE; /* TRUE when submatch() can be used */
+static int can_f_submatch = FALSE; // TRUE when submatch() can be used
-/* These pointers are used for reg_submatch(). Needed for when the
- * substitution string is an expression that contains a call to substitute()
- * and submatch(). */
+// These pointers are used for reg_submatch(). Needed for when the
+// substitution string is an expression that contains a call to substitute()
+// and submatch().
typedef struct {
regmatch_T *sm_match;
regmmatch_T *sm_mmatch;
int sm_line_lbr;
} regsubmatch_T;
-static regsubmatch_T rsm; /* can only be used when can_f_submatch is TRUE */
+static regsubmatch_T rsm; // can only be used when can_f_submatch is TRUE
#endif
#ifdef FEAT_EVAL
int rex_in_use_save = rex_in_use;
if (rex_in_use)
- /* Being called recursively, save the state. */
+ // Being called recursively, save the state.
rex_save = rex;
rex_in_use = TRUE;
int rex_in_use_save = rex_in_use;
if (rex_in_use)
- /* Being called recursively, save the state. */
+ // Being called recursively, save the state.
rex_save = rex;
rex_in_use = TRUE;
rex.reg_match = NULL;
rex.reg_mmatch = rmp;
- rex.reg_buf = curbuf; /* always works on the current buffer! */
+ rex.reg_buf = curbuf; // always works on the current buffer!
rex.reg_firstlnum = lnum;
rex.reg_maxline = curbuf->b_ml.ml_line_count - lnum;
rex.reg_line_lbr = FALSE;
int no = -1;
fptr_T func_all = (fptr_T)NULL;
fptr_T func_one = (fptr_T)NULL;
- linenr_T clnum = 0; /* init for GCC */
- int len = 0; /* init for GCC */
+ linenr_T clnum = 0; // init for GCC
+ int len = 0; // init for GCC
#ifdef FEAT_EVAL
static char_u *eval_result = NULL;
#endif
- /* Be paranoid... */
+ // Be paranoid...
if ((source == NULL && expr == NULL) || dest == NULL)
{
emsg(_(e_null));
if (expr != NULL || (source[0] == '\\' && source[1] == '='))
{
#ifdef FEAT_EVAL
- /* To make sure that the length doesn't change between checking the
- * length and copying the string, and to speed up things, the
- * resulting string is saved from the call with "copy" == FALSE to the
- * call with "copy" == TRUE. */
+ // To make sure that the length doesn't change between checking the
+ // length and copying the string, and to speed up things, the
+ // resulting string is saved from the call with "copy" == FALSE to the
+ // call with "copy" == TRUE.
if (copy)
{
if (eval_result != NULL)
vim_free(eval_result);
- /* The expression may contain substitute(), which calls us
- * recursively. Make sure submatch() gets the text from the first
- * level. */
+ // The expression may contain substitute(), which calls us
+ // recursively. Make sure submatch() gets the text from the first
+ // level.
if (can_f_submatch)
rsm_save = rsm;
can_f_submatch = TRUE;
for (s = eval_result; *s != NUL; MB_PTR_ADV(s))
{
- /* Change NL to CR, so that it becomes a line break,
- * unless called from vim_regexec_nl().
- * Skip over a backslashed character. */
+ // Change NL to CR, so that it becomes a line break,
+ // unless called from vim_regexec_nl().
+ // Skip over a backslashed character.
if (*s == NL && !rsm.sm_line_lbr)
*s = CAR;
else if (*s == '\\' && s[1] != NUL)
}
if (had_backslash && backslash)
{
- /* Backslashes will be consumed, need to double them. */
+ // Backslashes will be consumed, need to double them.
s = vim_strsave_escaped(eval_result, (char_u *)"\\");
if (s != NULL)
{
}
}
}
- if (no < 0) /* Ordinary character. */
+ if (no < 0) // Ordinary character.
{
if (c == K_SPECIAL && src[0] != NUL && src[1] != NUL)
{
- /* Copy a special key as-is. */
+ // Copy a special key as-is.
if (copy)
{
*dst++ = c;
if (c == '\\' && *src != NUL)
{
- /* Check for abbreviations -- webb */
+ // Check for abbreviations -- webb
switch (*src)
{
case 'r': c = CAR; ++src; break;
case 'n': c = NL; ++src; break;
case 't': c = TAB; ++src; break;
- /* Oh no! \e already has meaning in subst pat :-( */
- /* case 'e': c = ESC; ++src; break; */
+ // Oh no! \e already has meaning in subst pat :-(
+ // case 'e': c = ESC; ++src; break;
case 'b': c = Ctrl_H; ++src; break;
- /* If "backslash" is TRUE the backslash will be removed
- * later. Used to insert a literal CR. */
+ // If "backslash" is TRUE the backslash will be removed
+ // later. Used to insert a literal CR.
default: if (backslash)
{
if (copy)
else if (has_mbyte)
c = mb_ptr2char(src - 1);
- /* Write to buffer, if copy is set. */
+ // Write to buffer, if copy is set.
if (func_one != (fptr_T)NULL)
- /* Turbo C complains without the typecast */
+ // Turbo C complains without the typecast
func_one = (fptr_T)(func_one(&cc, c));
else if (func_all != (fptr_T)NULL)
- /* Turbo C complains without the typecast */
+ // Turbo C complains without the typecast
func_all = (fptr_T)(func_all(&cc, c));
- else /* just copy */
+ else // just copy
cc = c;
if (has_mbyte)
{
int clen = utf_ptr2len(src - 1);
- /* If the character length is shorter than "totlen", there
- * are composing characters; copy them as-is. */
+ // If the character length is shorter than "totlen", there
+ // are composing characters; copy them as-is.
if (clen < totlen)
{
if (copy)
else
break;
}
- else if (*s == NUL) /* we hit NUL. */
+ else if (*s == NUL) // we hit NUL.
{
if (copy)
emsg(_(e_re_damg));
c = *s;
if (func_one != (fptr_T)NULL)
- /* Turbo C complains without the typecast */
+ // Turbo C complains without the typecast
func_one = (fptr_T)(func_one(&cc, c));
else if (func_all != (fptr_T)NULL)
- /* Turbo C complains without the typecast */
+ // Turbo C complains without the typecast
func_all = (fptr_T)(func_all(&cc, c));
- else /* just copy */
+ else // just copy
cc = c;
if (has_mbyte)
{
int l;
- /* Copy composing characters separately, one
- * at a time. */
+ // Copy composing characters separately, one
+ // at a time.
if (enc_utf8)
l = utf_ptr2len(s) - 1;
else
s += rsm.sm_mmatch->startpos[no].col;
if (rsm.sm_mmatch->endpos[no].lnum == lnum)
{
- /* Within one line: take form start to end col. */
+ // Within one line: take form start to end col.
len = rsm.sm_mmatch->endpos[no].col
- rsm.sm_mmatch->startpos[no].col;
if (round == 2)
}
else
{
- /* Multiple lines: take start line from start col, middle
- * lines completely and end line up to end col. */
+ // Multiple lines: take start line from start col, middle
+ // lines completely and end line up to end col.
len = (int)STRLEN(s);
if (round == 2)
{
(char_u *)""
};
-/* Which regexp engine to use? Needed for vim_regcomp().
- * Must match with 'regexpengine'. */
+// Which regexp engine to use? Needed for vim_regcomp().
+// Must match with 'regexpengine'.
static int regexp_engine = 0;
#ifdef DEBUG
regexp_engine = p_re;
- /* Check for prefix "\%#=", that sets the regexp engine */
+ // Check for prefix "\%#=", that sets the regexp engine
if (STRNCMP(expr, "\\%#=", 4) == 0)
{
int newengine = expr[4] - '0';
else
prog = bt_regengine.regcomp(expr, re_flags);
- /* Check for error compiling regexp with initial engine. */
+ // Check for error compiling regexp with initial engine.
if (prog == NULL)
{
#ifdef BT_REGEXP_DEBUG_LOG
- if (regexp_engine != BACKTRACKING_ENGINE) /* debugging log for NFA */
+ if (regexp_engine != BACKTRACKING_ENGINE) // debugging log for NFA
{
FILE *f;
f = fopen(BT_REGEXP_DEBUG_LOG_NAME, "a");
if (prog != NULL)
{
- /* Store the info needed to call regcomp() again when the engine turns
- * out to be very slow when executing it. */
+ // Store the info needed to call regcomp() again when the engine turns
+ // out to be very slow when executing it.
prog->re_engine = regexp_engine;
prog->re_flags = re_flags;
}
static int
vim_regexec_string(
regmatch_T *rmp,
- char_u *line, /* string to match against */
- colnr_T col, /* column to start looking for match */
+ char_u *line, // string to match against
+ colnr_T col, // column to start looking for match
int nl)
{
int result;
result = rmp->regprog->engine->regexec_nl(rmp, line, col, nl);
rmp->regprog->re_in_use = FALSE;
- /* NFA engine aborted because it's very slow. */
+ // NFA engine aborted because it's very slow.
if (rmp->regprog->re_engine == AUTOMATIC_ENGINE
&& result == NFA_TOO_EXPENSIVE)
{
long
vim_regexec_multi(
regmmatch_T *rmp,
- win_T *win, /* window in which to search or NULL */
- buf_T *buf, /* buffer in which to search */
- linenr_T lnum, /* nr of line to start looking for match */
- colnr_T col, /* column to start looking for match */
- proftime_T *tm, /* timeout limit or NULL */
- int *timed_out) /* flag is set when timeout limit reached */
+ win_T *win, // window in which to search or NULL
+ buf_T *buf, // buffer in which to search
+ linenr_T lnum, // nr of line to start looking for match
+ colnr_T col, // column to start looking for match
+ proftime_T *tm, // timeout limit or NULL
+ int *timed_out) // flag is set when timeout limit reached
{
int result;
regexec_T rex_save;
rmp->regprog->re_in_use = TRUE;
if (rex_in_use)
- /* Being called recursively, save the state. */
+ // Being called recursively, save the state.
rex_save = rex;
rex_in_use = TRUE;
rmp, win, buf, lnum, col, tm, timed_out);
rmp->regprog->re_in_use = FALSE;
- /* NFA engine aborted because it's very slow. */
+ // NFA engine aborted because it's very slow.
if (rmp->regprog->re_engine == AUTOMATIC_ENGINE
&& result == NFA_TOO_EXPENSIVE)
{
# define NFA_REGEXP_DEBUG_LOG "nfa_regexp_debug.log"
#endif
-/* Added to NFA_ANY - NFA_NUPPER_IC to include a NL. */
+// Added to NFA_ANY - NFA_NUPPER_IC to include a NL.
#define NFA_ADD_NL 31
enum
{
NFA_SPLIT = -1024,
NFA_MATCH,
- NFA_EMPTY, /* matches 0-length */
-
- NFA_START_COLL, /* [abc] start */
- NFA_END_COLL, /* [abc] end */
- NFA_START_NEG_COLL, /* [^abc] start */
- NFA_END_NEG_COLL, /* [^abc] end (postfix only) */
- NFA_RANGE, /* range of the two previous items
- * (postfix only) */
- NFA_RANGE_MIN, /* low end of a range */
- NFA_RANGE_MAX, /* high end of a range */
-
- NFA_CONCAT, /* concatenate two previous items (postfix
- * only) */
- NFA_OR, /* \| (postfix only) */
- NFA_STAR, /* greedy * (postfix only) */
- NFA_STAR_NONGREEDY, /* non-greedy * (postfix only) */
- NFA_QUEST, /* greedy \? (postfix only) */
- NFA_QUEST_NONGREEDY, /* non-greedy \? (postfix only) */
-
- NFA_BOL, /* ^ Begin line */
- NFA_EOL, /* $ End line */
- NFA_BOW, /* \< Begin word */
- NFA_EOW, /* \> End word */
- NFA_BOF, /* \%^ Begin file */
- NFA_EOF, /* \%$ End file */
+ NFA_EMPTY, // matches 0-length
+
+ NFA_START_COLL, // [abc] start
+ NFA_END_COLL, // [abc] end
+ NFA_START_NEG_COLL, // [^abc] start
+ NFA_END_NEG_COLL, // [^abc] end (postfix only)
+ NFA_RANGE, // range of the two previous items
+ // (postfix only)
+ NFA_RANGE_MIN, // low end of a range
+ NFA_RANGE_MAX, // high end of a range
+
+ NFA_CONCAT, // concatenate two previous items (postfix
+ // only)
+ NFA_OR, // \| (postfix only)
+ NFA_STAR, // greedy * (postfix only)
+ NFA_STAR_NONGREEDY, // non-greedy * (postfix only)
+ NFA_QUEST, // greedy \? (postfix only)
+ NFA_QUEST_NONGREEDY, // non-greedy \? (postfix only)
+
+ NFA_BOL, // ^ Begin line
+ NFA_EOL, // $ End line
+ NFA_BOW, // \< Begin word
+ NFA_EOW, // \> End word
+ NFA_BOF, // \%^ Begin file
+ NFA_EOF, // \%$ End file
NFA_NEWL,
- NFA_ZSTART, /* Used for \zs */
- NFA_ZEND, /* Used for \ze */
- NFA_NOPEN, /* Start of subexpression marked with \%( */
- NFA_NCLOSE, /* End of subexpr. marked with \%( ... \) */
+ NFA_ZSTART, // Used for \zs
+ NFA_ZEND, // Used for \ze
+ NFA_NOPEN, // Start of subexpression marked with \%(
+ NFA_NCLOSE, // End of subexpr. marked with \%( ... \)
NFA_START_INVISIBLE,
NFA_START_INVISIBLE_FIRST,
NFA_START_INVISIBLE_NEG,
NFA_END_INVISIBLE,
NFA_END_INVISIBLE_NEG,
NFA_END_PATTERN,
- NFA_COMPOSING, /* Next nodes in NFA are part of the
- composing multibyte char */
- NFA_END_COMPOSING, /* End of a composing char in the NFA */
- NFA_ANY_COMPOSING, /* \%C: Any composing characters. */
- NFA_OPT_CHARS, /* \%[abc] */
-
- /* The following are used only in the postfix form, not in the NFA */
- NFA_PREV_ATOM_NO_WIDTH, /* Used for \@= */
- NFA_PREV_ATOM_NO_WIDTH_NEG, /* Used for \@! */
- NFA_PREV_ATOM_JUST_BEFORE, /* Used for \@<= */
- NFA_PREV_ATOM_JUST_BEFORE_NEG, /* Used for \@<! */
- NFA_PREV_ATOM_LIKE_PATTERN, /* Used for \@> */
-
- NFA_BACKREF1, /* \1 */
- NFA_BACKREF2, /* \2 */
- NFA_BACKREF3, /* \3 */
- NFA_BACKREF4, /* \4 */
- NFA_BACKREF5, /* \5 */
- NFA_BACKREF6, /* \6 */
- NFA_BACKREF7, /* \7 */
- NFA_BACKREF8, /* \8 */
- NFA_BACKREF9, /* \9 */
+ NFA_COMPOSING, // Next nodes in NFA are part of the
+ // composing multibyte char
+ NFA_END_COMPOSING, // End of a composing char in the NFA
+ NFA_ANY_COMPOSING, // \%C: Any composing characters.
+ NFA_OPT_CHARS, // \%[abc]
+
+ // The following are used only in the postfix form, not in the NFA
+ NFA_PREV_ATOM_NO_WIDTH, // Used for \@=
+ NFA_PREV_ATOM_NO_WIDTH_NEG, // Used for \@!
+ NFA_PREV_ATOM_JUST_BEFORE, // Used for \@<=
+ NFA_PREV_ATOM_JUST_BEFORE_NEG, // Used for \@<!
+ NFA_PREV_ATOM_LIKE_PATTERN, // Used for \@>
+
+ NFA_BACKREF1, // \1
+ NFA_BACKREF2, // \2
+ NFA_BACKREF3, // \3
+ NFA_BACKREF4, // \4
+ NFA_BACKREF5, // \5
+ NFA_BACKREF6, // \6
+ NFA_BACKREF7, // \7
+ NFA_BACKREF8, // \8
+ NFA_BACKREF9, // \9
#ifdef FEAT_SYN_HL
- NFA_ZREF1, /* \z1 */
- NFA_ZREF2, /* \z2 */
- NFA_ZREF3, /* \z3 */
- NFA_ZREF4, /* \z4 */
- NFA_ZREF5, /* \z5 */
- NFA_ZREF6, /* \z6 */
- NFA_ZREF7, /* \z7 */
- NFA_ZREF8, /* \z8 */
- NFA_ZREF9, /* \z9 */
+ NFA_ZREF1, // \z1
+ NFA_ZREF2, // \z2
+ NFA_ZREF3, // \z3
+ NFA_ZREF4, // \z4
+ NFA_ZREF5, // \z5
+ NFA_ZREF6, // \z6
+ NFA_ZREF7, // \z7
+ NFA_ZREF8, // \z8
+ NFA_ZREF9, // \z9
#endif
- NFA_SKIP, /* Skip characters */
+ NFA_SKIP, // Skip characters
NFA_MOPEN,
NFA_MOPEN1,
NFA_ZCLOSE9,
#endif
- /* NFA_FIRST_NL */
- NFA_ANY, /* Match any one character. */
- NFA_IDENT, /* Match identifier char */
- NFA_SIDENT, /* Match identifier char but no digit */
- NFA_KWORD, /* Match keyword char */
- NFA_SKWORD, /* Match word char but no digit */
- NFA_FNAME, /* Match file name char */
- NFA_SFNAME, /* Match file name char but no digit */
- NFA_PRINT, /* Match printable char */
- NFA_SPRINT, /* Match printable char but no digit */
- NFA_WHITE, /* Match whitespace char */
- NFA_NWHITE, /* Match non-whitespace char */
- NFA_DIGIT, /* Match digit char */
- NFA_NDIGIT, /* Match non-digit char */
- NFA_HEX, /* Match hex char */
- NFA_NHEX, /* Match non-hex char */
- NFA_OCTAL, /* Match octal char */
- NFA_NOCTAL, /* Match non-octal char */
- NFA_WORD, /* Match word char */
- NFA_NWORD, /* Match non-word char */
- NFA_HEAD, /* Match head char */
- NFA_NHEAD, /* Match non-head char */
- NFA_ALPHA, /* Match alpha char */
- NFA_NALPHA, /* Match non-alpha char */
- NFA_LOWER, /* Match lowercase char */
- NFA_NLOWER, /* Match non-lowercase char */
- NFA_UPPER, /* Match uppercase char */
- NFA_NUPPER, /* Match non-uppercase char */
- NFA_LOWER_IC, /* Match [a-z] */
- NFA_NLOWER_IC, /* Match [^a-z] */
- NFA_UPPER_IC, /* Match [A-Z] */
- NFA_NUPPER_IC, /* Match [^A-Z] */
+ // NFA_FIRST_NL
+ NFA_ANY, // Match any one character.
+ NFA_IDENT, // Match identifier char
+ NFA_SIDENT, // Match identifier char but no digit
+ NFA_KWORD, // Match keyword char
+ NFA_SKWORD, // Match word char but no digit
+ NFA_FNAME, // Match file name char
+ NFA_SFNAME, // Match file name char but no digit
+ NFA_PRINT, // Match printable char
+ NFA_SPRINT, // Match printable char but no digit
+ NFA_WHITE, // Match whitespace char
+ NFA_NWHITE, // Match non-whitespace char
+ NFA_DIGIT, // Match digit char
+ NFA_NDIGIT, // Match non-digit char
+ NFA_HEX, // Match hex char
+ NFA_NHEX, // Match non-hex char
+ NFA_OCTAL, // Match octal char
+ NFA_NOCTAL, // Match non-octal char
+ NFA_WORD, // Match word char
+ NFA_NWORD, // Match non-word char
+ NFA_HEAD, // Match head char
+ NFA_NHEAD, // Match non-head char
+ NFA_ALPHA, // Match alpha char
+ NFA_NALPHA, // Match non-alpha char
+ NFA_LOWER, // Match lowercase char
+ NFA_NLOWER, // Match non-lowercase char
+ NFA_UPPER, // Match uppercase char
+ NFA_NUPPER, // Match non-uppercase char
+ NFA_LOWER_IC, // Match [a-z]
+ NFA_NLOWER_IC, // Match [^a-z]
+ NFA_UPPER_IC, // Match [A-Z]
+ NFA_NUPPER_IC, // Match [^A-Z]
NFA_FIRST_NL = NFA_ANY + NFA_ADD_NL,
NFA_LAST_NL = NFA_NUPPER_IC + NFA_ADD_NL,
- NFA_CURSOR, /* Match cursor pos */
- NFA_LNUM, /* Match line number */
- NFA_LNUM_GT, /* Match > line number */
- NFA_LNUM_LT, /* Match < line number */
- NFA_COL, /* Match cursor column */
- NFA_COL_GT, /* Match > cursor column */
- NFA_COL_LT, /* Match < cursor column */
- NFA_VCOL, /* Match cursor virtual column */
- NFA_VCOL_GT, /* Match > cursor virtual column */
- NFA_VCOL_LT, /* Match < cursor virtual column */
- NFA_MARK, /* Match mark */
- NFA_MARK_GT, /* Match > mark */
- NFA_MARK_LT, /* Match < mark */
- NFA_VISUAL, /* Match Visual area */
-
- /* Character classes [:alnum:] etc */
+ NFA_CURSOR, // Match cursor pos
+ NFA_LNUM, // Match line number
+ NFA_LNUM_GT, // Match > line number
+ NFA_LNUM_LT, // Match < line number
+ NFA_COL, // Match cursor column
+ NFA_COL_GT, // Match > cursor column
+ NFA_COL_LT, // Match < cursor column
+ NFA_VCOL, // Match cursor virtual column
+ NFA_VCOL_GT, // Match > cursor virtual column
+ NFA_VCOL_LT, // Match < cursor virtual column
+ NFA_MARK, // Match mark
+ NFA_MARK_GT, // Match > mark
+ NFA_MARK_LT, // Match < mark
+ NFA_VISUAL, // Match Visual area
+
+ // Character classes [:alnum:] etc
NFA_CLASS_ALNUM,
NFA_CLASS_ALPHA,
NFA_CLASS_BLANK,
NFA_CLASS_FNAME
};
-/* Keep in sync with classchars. */
+// Keep in sync with classchars.
static int nfa_classcodes[] = {
NFA_ANY, NFA_IDENT, NFA_SIDENT, NFA_KWORD,NFA_SKWORD,
NFA_FNAME, NFA_SFNAME, NFA_PRINT, NFA_SPRINT,
static int nstate; // Number of states in the NFA.
static int istate; // Index in the state vector, used in alloc_state()
-/* If not NULL match must end at this position */
+// If not NULL match must end at this position
static save_se_T *nfa_endp = NULL;
-/* 0 for first call to nfa_regmatch(), 1 for recursive call. */
+// 0 for first call to nfa_regmatch(), 1 for recursive call.
static int nfa_ll_index = 0;
static int realloc_post_list(void);
static int match_follows(nfa_state_T *startstate, int depth);
static int failure_chance(nfa_state_T *state, int depth);
-/* helper functions used when doing re2post() ... regatom() parsing */
+// helper functions used when doing re2post() ... regatom() parsing
#define EMIT(c) do { \
if (post_ptr >= post_end && realloc_post_list() == FAIL) \
return FAIL; \
static int
nfa_regcomp_start(
char_u *expr,
- int re_flags) /* see vim_regcomp() */
+ int re_flags) // see vim_regcomp()
{
size_t postfix_size;
int nstate_max;
nstate = 0;
istate = 0;
- /* A reasonable estimation for maximum size */
+ // A reasonable estimation for maximum size
nstate_max = (int)(STRLEN(expr) + 1) * 25;
- /* Some items blow up in size, such as [A-z]. Add more space for that.
- * When it is still not enough realloc_post_list() will be used. */
+ // Some items blow up in size, such as [A-z]. Add more space for that.
+ // When it is still not enough realloc_post_list() will be used.
nstate_max += 1000;
- /* Size for postfix representation of expr. */
+ // Size for postfix representation of expr.
postfix_size = sizeof(int) * nstate_max;
post_start = alloc(postfix_size);
rex.nfa_has_zend = FALSE;
rex.nfa_has_backref = FALSE;
- /* shared with BT engine */
+ // shared with BT engine
regcomp_start(expr, re_flags);
return OK;
{
case NFA_BOL:
case NFA_BOF:
- return 1; /* yes! */
+ return 1; // yes!
case NFA_ZSTART:
case NFA_ZEND:
&& nfa_get_reganch(p->out1, depth + 1);
default:
- return 0; /* noooo */
+ return 0; // noooo
}
}
return 0;
{
switch (p->c)
{
- /* all kinds of zero-width matches */
+ // all kinds of zero-width matches
case NFA_BOL:
case NFA_BOF:
case NFA_BOW:
int c2 = nfa_get_regstart(p->out1, depth + 1);
if (c1 == c2)
- return c1; /* yes! */
+ return c1; // yes!
return 0;
}
default:
if (p->c > 0)
- return p->c; /* yes! */
+ return p->c; // yes!
return 0;
}
}
char_u *s;
if (p->c != NFA_MOPEN)
- return NULL; /* just in case */
+ return NULL; // just in case
p = p->out;
while (p->c > 0)
{
ret = alloc(len);
if (ret != NULL)
{
- p = start->out->out; /* skip first char, it goes into regstart */
+ p = start->out->out; // skip first char, it goes into regstart
s = ret;
while (p->c > 0)
{
}
else
return FAIL;
- } /* while (p < end) */
+ } // while (p < end)
if (p != end)
return FAIL;
EMITMBC(0x1b6) EMITMBC(0x1e91) EMITMBC(0x1e95)
return OK;
- /* default: character itself */
+ // default: character itself
}
}
if (c == NUL)
EMSG_RET_FAIL(_(e_nul_found));
- if (c == '^') /* "\_^" is start-of-line */
+ if (c == '^') // "\_^" is start-of-line
{
EMIT(NFA_BOL);
break;
}
- if (c == '$') /* "\_$" is end-of-line */
+ if (c == '$') // "\_$" is end-of-line
{
EMIT(NFA_EOL);
#if defined(FEAT_SYN_HL) || defined(PROTO)
extra = NFA_ADD_NL;
- /* "\_[" is collection plus newline */
+ // "\_[" is collection plus newline
if (c == '[')
goto collection;
- /* "\_x" is character class plus newline */
- /* FALLTHROUGH */
+ // "\_x" is character class plus newline
+ // FALLTHROUGH
/*
* Character classes.
return FAIL;
}
- /* When '.' is followed by a composing char ignore the dot, so that
- * the composing char is matched here. */
+ // When '.' is followed by a composing char ignore the dot, so that
+ // the composing char is matched here.
if (enc_utf8 && c == Magic('.') && utf_iscomposing(peekchr()))
{
old_regparse = regparse;
case Magic('n'):
if (reg_string)
- /* In a string "\n" matches a newline character. */
+ // In a string "\n" matches a newline character.
EMIT(NL);
else
{
- /* In buffer text "\n" matches the end of a line. */
+ // In buffer text "\n" matches the end of a line.
EMIT(NFA_NEWL);
regflags |= RF_HASNL;
}
case Magic('('):
if (nfa_reg(REG_PAREN) == FAIL)
- return FAIL; /* cascaded error */
+ return FAIL; // cascaded error
break;
case Magic('|'):
case Magic('@'):
case Magic('*'):
case Magic('{'):
- /* these should follow an atom, not form an atom */
+ // these should follow an atom, not form an atom
semsg(_(e_misplaced), no_Magic(c));
return FAIL;
{
char_u *lp;
- /* Previous substitute pattern.
- * Generated as "\%(pattern\)". */
+ // Previous substitute pattern.
+ // Generated as "\%(pattern\)".
if (reg_prev_sub == NULL)
{
emsg(_(e_nopresub));
case '7':
case '8':
case '9':
- /* \z1...\z9 */
+ // \z1...\z9
if ((reg_do_extmatch & REX_USE) == 0)
EMSG_RET_FAIL(_(e_z1_not_allowed));
EMIT(NFA_ZREF1 + (no_Magic(c) - '1'));
- /* No need to set rex.nfa_has_backref, the sub-matches don't
- * change when \z1 .. \z9 matches or not. */
+ // No need to set rex.nfa_has_backref, the sub-matches don't
+ // change when \z1 .. \z9 matches or not.
re_has_z = REX_USE;
break;
case '(':
- /* \z( */
+ // \z(
if ((reg_do_extmatch & REX_SET) == 0)
EMSG_RET_FAIL(_(e_z_not_allowed));
if (nfa_reg(REG_ZPAREN) == FAIL)
- return FAIL; /* cascaded error */
+ return FAIL; // cascaded error
re_has_z = REX_SET;
break;
#endif
c = no_Magic(getchr());
switch (c)
{
- /* () without a back reference */
+ // () without a back reference
case '(':
if (nfa_reg(REG_NPAREN) == FAIL)
return FAIL;
EMIT(NFA_NOPEN);
break;
- case 'd': /* %d123 decimal */
- case 'o': /* %o123 octal */
- case 'x': /* %xab hex 2 */
- case 'u': /* %uabcd hex 4 */
- case 'U': /* %U1234abcd hex 8 */
+ case 'd': // %d123 decimal
+ case 'o': // %o123 octal
+ case 'x': // %xab hex 2
+ case 'u': // %uabcd hex 4
+ case 'U': // %U1234abcd hex 8
{
long nr;
EMSG2_RET_FAIL(
_("E678: Invalid character after %s%%[dxouU]"),
reg_magic == MAGIC_ALL);
- /* A NUL is stored in the text as NL */
- /* TODO: what if a composing character follows? */
+ // A NUL is stored in the text as NL
+ // TODO: what if a composing character follows?
EMIT(nr == 0 ? 0x0a : nr);
}
break;
- /* Catch \%^ and \%$ regardless of where they appear in the
- * pattern -- regardless of whether or not it makes sense. */
+ // Catch \%^ and \%$ regardless of where they appear in the
+ // pattern -- regardless of whether or not it makes sense.
case '^':
EMIT(NFA_BOF);
break;
{
int n;
- /* \%[abc] */
+ // \%[abc]
for (n = 0; (c = peekchr()) != ']'; ++n)
{
if (c == NUL)
EMSG2_RET_FAIL(_(e_missing_sb),
reg_magic == MAGIC_ALL);
- /* recursive call! */
+ // recursive call!
if (nfa_regatom() == FAIL)
return FAIL;
}
- getchr(); /* get the ] */
+ getchr(); // get the ]
if (n == 0)
EMSG2_RET_FAIL(_(e_empty_sb),
reg_magic == MAGIC_ALL);
EMIT(NFA_OPT_CHARS);
EMIT(n);
- /* Emit as "\%(\%[abc]\)" to be able to handle
- * "\%[abc]*" which would cause the empty string to be
- * matched an unlimited number of times. NFA_NOPEN is
- * added only once at a position, while NFA_SPLIT is
- * added multiple times. This is more efficient than
- * not allowing NFA_SPLIT multiple times, it is used
- * a lot. */
+ // Emit as "\%(\%[abc]\)" to be able to handle
+ // "\%[abc]*" which would cause the empty string to be
+ // matched an unlimited number of times. NFA_NOPEN is
+ // added only once at a position, while NFA_SPLIT is
+ // added multiple times. This is more efficient than
+ // not allowing NFA_SPLIT multiple times, it is used
+ // a lot.
EMIT(NFA_NOPEN);
break;
}
if (c == 'l')
{
- /* \%{n}l \%{n}<l \%{n}>l */
+ // \%{n}l \%{n}<l \%{n}>l
EMIT(cmp == '<' ? NFA_LNUM_LT :
cmp == '>' ? NFA_LNUM_GT : NFA_LNUM);
if (save_prev_at_start)
at_start = TRUE;
}
else if (c == 'c')
- /* \%{n}c \%{n}<c \%{n}>c */
+ // \%{n}c \%{n}<c \%{n}>c
EMIT(cmp == '<' ? NFA_COL_LT :
cmp == '>' ? NFA_COL_GT : NFA_COL);
else
{
- /* \%{n}v \%{n}<v \%{n}>v */
+ // \%{n}v \%{n}<v \%{n}>v
EMIT(cmp == '<' ? NFA_VCOL_LT :
cmp == '>' ? NFA_VCOL_GT : NFA_VCOL);
limit = INT_MAX / MB_MAXBYTES;
}
else if (c == '\'' && n == 0)
{
- /* \%'m \%<'m \%>'m */
+ // \%'m \%<'m \%>'m
EMIT(cmp == '<' ? NFA_MARK_LT :
cmp == '>' ? NFA_MARK_GT : NFA_MARK);
EMIT(getchr());
*/
startc = endc = oldstartc = -1;
negated = FALSE;
- if (*regparse == '^') /* negated range */
+ if (*regparse == '^') // negated range
{
negated = TRUE;
MB_PTR_ADV(regparse);
EMIT(NFA_CONCAT);
MB_PTR_ADV(regparse);
}
- /* Emit the OR branches for each character in the [] */
+ // Emit the OR branches for each character in the []
emit_range = FALSE;
while (regparse < endp)
{
got_coll_char = FALSE;
if (*regparse == '[')
{
- /* Check for [: :], [= =], [. .] */
+ // Check for [: :], [= =], [. .]
equiclass = collclass = 0;
charclass = get_char_class(®parse);
if (charclass == CLASS_NONE)
collclass = get_coll_element(®parse);
}
- /* Character class like [:alpha:] */
+ // Character class like [:alpha:]
if (charclass != CLASS_NONE)
{
switch (charclass)
EMIT(NFA_CONCAT);
continue;
}
- /* Try equivalence class [=a=] and the like */
+ // Try equivalence class [=a=] and the like
if (equiclass != 0)
{
result = nfa_emit_equi_class(equiclass);
if (result == FAIL)
{
- /* should never happen */
+ // should never happen
EMSG_RET_FAIL(_("E868: Error building NFA with equivalence class!"));
}
continue;
}
- /* Try collating class like [. .] */
+ // Try collating class like [. .]
if (collclass != 0)
{
- startc = collclass; /* allow [.a.]-x as a range */
- /* Will emit the proper atom at the end of the
- * while loop. */
+ startc = collclass; // allow [.a.]-x as a range
+ // Will emit the proper atom at the end of the
+ // while loop.
}
}
- /* Try a range like 'a-x' or '\t-z'. Also allows '-' as a
- * start character. */
+ // Try a range like 'a-x' or '\t-z'. Also allows '-' as a
+ // start character.
if (*regparse == '-' && oldstartc != -1)
{
emit_range = TRUE;
startc = oldstartc;
MB_PTR_ADV(regparse);
- continue; /* reading the end of the range */
+ continue; // reading the end of the range
}
- /* Now handle simple and escaped characters.
- * Only "\]", "\^", "\]" and "\\" are special in Vi. Vim
- * accepts "\t", "\e", etc., but only when the 'l' flag in
- * 'cpoptions' is not included.
- * Posix doesn't recognize backslash at all.
- */
+ // Now handle simple and escaped characters.
+ // Only "\]", "\^", "\]" and "\\" are special in Vi. Vim
+ // accepts "\t", "\e", etc., but only when the 'l' flag in
+ // 'cpoptions' is not included.
+ // Posix doesn't recognize backslash at all.
if (*regparse == '\\'
&& !reg_cpo_bsl
&& regparse + 1 <= endp
|| *regparse == 'U'
)
{
- /* TODO(RE) This needs more testing */
+ // TODO(RE) This needs more testing
startc = coll_get_char();
got_coll_char = TRUE;
MB_PTR_BACK(old_regparse, regparse);
}
else
{
- /* \r,\t,\e,\b */
+ // \r,\t,\e,\b
startc = backslash_trans(*regparse);
}
}
- /* Normal printable char */
+ // Normal printable char
if (startc == -1)
startc = PTR2CHAR(regparse);
- /* Previous char was '-', so this char is end of range. */
+ // Previous char was '-', so this char is end of range.
if (emit_range)
{
endc = startc;
if (endc > startc + 2)
{
- /* Emit a range instead of the sequence of
- * individual characters. */
+ // Emit a range instead of the sequence of
+ // individual characters.
if (startc == 0)
- /* \x00 is translated to \x0a, start at \x01. */
+ // \x00 is translated to \x0a, start at \x01.
EMIT(1);
else
- --post_ptr; /* remove NFA_CONCAT */
+ --post_ptr; // remove NFA_CONCAT
EMIT(endc);
EMIT(NFA_RANGE);
EMIT(NFA_CONCAT);
else if (has_mbyte && ((*mb_char2len)(startc) > 1
|| (*mb_char2len)(endc) > 1))
{
- /* Emit the characters in the range.
- * "startc" was already emitted, so skip it.
- * */
+ // Emit the characters in the range.
+ // "startc" was already emitted, so skip it.
+ //
for (c = startc + 1; c <= endc; c++)
{
EMIT(c);
#ifdef EBCDIC
int alpha_only = FALSE;
- /* for alphabetical range skip the gaps
- * 'i'-'j', 'r'-'s', 'I'-'J' and 'R'-'S'. */
+ // for alphabetical range skip the gaps
+ // 'i'-'j', 'r'-'s', 'I'-'J' and 'R'-'S'.
if (isalpha(startc) && isalpha(endc))
alpha_only = TRUE;
#endif
- /* Emit the range. "startc" was already emitted, so
- * skip it. */
+ // Emit the range. "startc" was already emitted, so
+ // skip it.
for (c = startc + 1; c <= endc; c++)
#ifdef EBCDIC
if (!alpha_only || isalpha(startc))
}
else
{
- /* This char (startc) is not part of a range. Just
- * emit it.
- * Normally, simply emit startc. But if we get char
- * code=0 from a collating char, then replace it with
- * 0x0a.
- * This is needed to completely mimic the behaviour of
- * the backtracking engine. */
+ // This char (startc) is not part of a range. Just
+ // emit it.
+ // Normally, simply emit startc. But if we get char
+ // code=0 from a collating char, then replace it with
+ // 0x0a.
+ // This is needed to completely mimic the behaviour of
+ // the backtracking engine.
if (startc == NFA_NEWL)
{
- /* Line break can't be matched as part of the
- * collection, add an OR below. But not for negated
- * range. */
+ // Line break can't be matched as part of the
+ // collection, add an OR below. But not for negated
+ // range.
if (!negated)
extra = NFA_ADD_NL;
}
}
MB_PTR_ADV(regparse);
- } /* while (p < endp) */
+ } // while (p < endp)
MB_PTR_BACK(old_regparse, regparse);
- if (*regparse == '-') /* if last, '-' is just a char */
+ if (*regparse == '-') // if last, '-' is just a char
{
EMIT('-');
EMIT(NFA_CONCAT);
}
- /* skip the trailing ] */
+ // skip the trailing ]
regparse = endp;
MB_PTR_ADV(regparse);
- /* Mark end of the collection. */
+ // Mark end of the collection.
if (negated == TRUE)
EMIT(NFA_END_NEG_COLL);
else
EMIT(NFA_END_COLL);
- /* \_[] also matches \n but it's not negated */
+ // \_[] also matches \n but it's not negated
if (extra == NFA_ADD_NL)
{
EMIT(reg_string ? NL : NFA_NEWL);
}
return OK;
- } /* if exists closing ] */
+ } // if exists closing ]
if (reg_strict)
EMSG_RET_FAIL(_(e_missingbracket));
- /* FALLTHROUGH */
+ // FALLTHROUGH
default:
{
int plen;
nfa_do_multibyte:
- /* plen is length of current char with composing chars */
+ // plen is length of current char with composing chars
if (enc_utf8 && ((*mb_char2len)(c)
!= (plen = utfc_ptr2len(old_regparse))
|| utf_iscomposing(c)))
{
int i = 0;
- /* A base character plus composing characters, or just one
- * or more composing characters.
- * This requires creating a separate atom as if enclosing
- * the characters in (), where NFA_COMPOSING is the ( and
- * NFA_END_COMPOSING is the ). Note that right now we are
- * building the postfix form, not the NFA itself;
- * a composing char could be: a, b, c, NFA_COMPOSING
- * where 'b' and 'c' are chars with codes > 256. */
+ // A base character plus composing characters, or just one
+ // or more composing characters.
+ // This requires creating a separate atom as if enclosing
+ // the characters in (), where NFA_COMPOSING is the ( and
+ // NFA_END_COMPOSING is the ). Note that right now we are
+ // building the postfix form, not the NFA itself;
+ // a composing char could be: a, b, c, NFA_COMPOSING
+ // where 'b' and 'c' are chars with codes > 256.
for (;;)
{
EMIT(c);
int op;
int ret;
long minval, maxval;
- int greedy = TRUE; /* Braces are prefixed with '-' ? */
+ int greedy = TRUE; // Braces are prefixed with '-' ?
parse_state_T old_state;
parse_state_T new_state;
long c2;
int my_post_start;
int quest;
- /
* Save the current parse state, so that we can use it if <atom>{m,n} is
- * next. */
+ /
/ Save the current parse state, so that we can use it if <atom>{m,n} is
+ // next.
save_parse_state(&old_state);
- /* store current pos in the postfix form, for \{m,n} involving 0s */
+ // store current pos in the postfix form, for \{m,n} involving 0s
my_post_start = (int)(post_ptr - post_start);
ret = nfa_regatom();
if (ret == FAIL)
- return FAIL; /* cascaded error */
+ return FAIL; // cascaded error
op = peekchr();
if (re_multi_type(op) == NOT_MULTI)
return FAIL;
EMIT(NFA_STAR);
EMIT(NFA_CONCAT);
- skipchr(); /* skip the \+ */
+ skipchr(); // skip the \+
break;
case Magic('@'):
switch(op)
{
case '=':
- /* \@= */
+ // \@=
i = NFA_PREV_ATOM_NO_WIDTH;
break;
case '!':
- /* \@! */
+ // \@!
i = NFA_PREV_ATOM_NO_WIDTH_NEG;
break;
case '<':
op = no_Magic(getchr());
if (op == '=')
- /* \@<= */
+ // \@<=
i = NFA_PREV_ATOM_JUST_BEFORE;
else if (op == '!')
- /* \@<! */
+ // \@<!
i = NFA_PREV_ATOM_JUST_BEFORE_NEG;
break;
case '>':
- /* \@> */
+ // \@>
i = NFA_PREV_ATOM_LIKE_PATTERN;
break;
}
break;
case Magic('{'):
- /* a{2,5} will expand to 'aaa?a?a?'
- * a{-1,3} will expand to 'aa??a??', where ?? is the nongreedy
- * version of '?'
- * \v(ab){2,3} will expand to '(ab)(ab)(ab)?', where all the
- * parenthesis have the same id
- */
+ // a{2,5} will expand to 'aaa?a?a?'
+ // a{-1,3} will expand to 'aa??a??', where ?? is the nongreedy
+ // version of '?'
+ // \v(ab){2,3} will expand to '(ab)(ab)(ab)?', where all the
+ // parenthesis have the same id
greedy = TRUE;
c2 = peekchr();
if (!read_limits(&minval, &maxval))
EMSG_RET_FAIL(_("E870: (NFA regexp) Error reading repetition limits"));
- /
* <atom>{0,inf}, <atom>{0,} and <atom>{} are equivalent to
- * <atom>* */
+ /
/ <atom>{0,inf}, <atom>{0,} and <atom>{} are equivalent to
+ // <atom>*
if (minval == 0 && maxval == MAX_LIMIT)
{
- if (greedy) /* { { (match the braces) */
- /* \{}, \{0,} */
+ if (greedy) // { { (match the braces)
+ // \{}, \{0,}
EMIT(NFA_STAR);
- else /* { { (match the braces) */
- /* \{-}, \{-0,} */
+ else // { { (match the braces)
+ // \{-}, \{-0,}
EMIT(NFA_STAR_NONGREEDY);
break;
}
- /* Special case: x{0} or x{-0} */
+ // Special case: x{0} or x{-0}
if (maxval == 0)
{
- /* Ignore result of previous call to nfa_regatom() */
+ // Ignore result of previous call to nfa_regatom()
post_ptr = post_start + my_post_start;
- /* NFA_EMPTY is 0-length and works everywhere */
+ // NFA_EMPTY is 0-length and works everywhere
EMIT(NFA_EMPTY);
return OK;
}
- /* The engine is very inefficient (uses too many states) when the
- * maximum is much larger than the minimum and when the maximum is
- * large. Bail out if we can use the other engine. */
+ // The engine is very inefficient (uses too many states) when the
+ // maximum is much larger than the minimum and when the maximum is
+ // large. Bail out if we can use the other engine.
if ((nfa_re_flags & RE_AUTO)
&& (maxval > 500 || maxval > minval + 200))
return FAIL;
- /* Ignore previous call to nfa_regatom() */
+ // Ignore previous call to nfa_regatom()
post_ptr = post_start + my_post_start;
- /* Save parse state after the repeated atom and the \{} */
+ // Save parse state after the repeated atom and the \{}
save_parse_state(&new_state);
quest = (greedy == TRUE? NFA_QUEST : NFA_QUEST_NONGREEDY);
for (i = 0; i < maxval; i++)
{
- /* Goto beginning of the repeated atom */
+ // Goto beginning of the repeated atom
restore_parse_state(&old_state);
old_post_pos = (int)(post_ptr - post_start);
if (nfa_regatom() == FAIL)
return FAIL;
- /* after "minval" times, atoms are optional */
+ // after "minval" times, atoms are optional
if (i + 1 > minval)
{
if (maxval == MAX_LIMIT)
break;
}
- /* Go to just after the repeated atom and the \{} */
+ // Go to just after the repeated atom and the \{}
restore_parse_state(&new_state);
curchr = -1;
default:
break;
- } /* end switch */
+ } // end switch
if (re_multi_type(peekchr()) != NOT_MULTI)
- /* Can't have a multi follow a multi. */
+ // Can't have a multi follow a multi.
EMSG_RET_FAIL(_("E871: (NFA regexp) Can't have a multi follow a multi"));
return OK;
old_post_pos = (int)(post_ptr - post_start);
- /* First branch, possibly the only one */
+ // First branch, possibly the only one
if (nfa_regconcat() == FAIL)
return FAIL;
- /* Try next concats */
+ // Try next concats
while (peekchr() == Magic('&'))
{
skipchr();
- /* if concat is empty do emit a node */
+ // if concat is empty do emit a node
if (old_post_pos == (int)(post_ptr - post_start))
EMIT(NFA_EMPTY);
EMIT(NFA_NOPEN);
old_post_pos = (int)(post_ptr - post_start);
if (nfa_regconcat() == FAIL)
return FAIL;
- /* if concat is empty do emit a node */
+ // if concat is empty do emit a node
if (old_post_pos == (int)(post_ptr - post_start))
EMIT(NFA_EMPTY);
EMIT(NFA_CONCAT);
}
- /* if a branch is empty, emit one node for it */
+ // if a branch is empty, emit one node for it
if (old_post_pos == (int)(post_ptr - post_start))
EMIT(NFA_EMPTY);
*/
static int
nfa_reg(
- int paren) /* REG_NOPAREN, REG_PAREN, REG_NPAREN or REG_ZPAREN */
+ int paren) // REG_NOPAREN, REG_PAREN, REG_NPAREN or REG_ZPAREN
{
int parno = 0;
if (paren == REG_PAREN)
{
- if (regnpar >= NSUBEXP) /* Too many `(' */
+ if (regnpar >= NSUBEXP) // Too many `('
EMSG_RET_FAIL(_("E872: (NFA regexp) Too many '('"));
parno = regnpar++;
}
#ifdef FEAT_SYN_HL
else if (paren == REG_ZPAREN)
{
- /* Make a ZOPEN node. */
+ // Make a ZOPEN node.
if (regnzpar >= NSUBEXP)
EMSG_RET_FAIL(_("E879: (NFA regexp) Too many \\z("));
parno = regnzpar++;
#endif
if (nfa_regbranch() == FAIL)
- return FAIL; /* cascaded error */
+ return FAIL; // cascaded error
while (peekchr() == Magic('|'))
{
skipchr();
if (nfa_regbranch() == FAIL)
- return FAIL; /* cascaded error */
+ return FAIL; // cascaded error
EMIT(NFA_OR);
}
- /* Check for proper termination. */
+ // Check for proper termination.
if (paren != REG_NOPAREN && getchr() != Magic(')'))
{
if (paren == REG_NPAREN)
*/
if (paren == REG_PAREN)
{
- had_endbrace[parno] = TRUE; /* have seen the close paren */
+ had_endbrace[parno] = TRUE; // have seen the close paren
EMIT(NFA_MOPEN + parno);
}
#ifdef FEAT_SYN_HL
fprintf(debugf, "(%2d)", abs(state->id));
- /* Output indent */
+ // Output indent
p = (char_u *)indent->ga_data;
if (indent->ga_len >= 3)
{
state->id = abs(state->id) * -1;
- /* grow indent for state->out */
+ // grow indent for state->out
indent->ga_len -= 1;
if (state->out1)
ga_concat(indent, (char_u *)"| ");
nfa_print_state2(debugf, state->out, indent);
- /* replace last part of indent for state->out1 */
+ // replace last part of indent for state->out1
indent->ga_len -= 3;
ga_concat(indent, (char_u *)" ");
ga_append(indent, '\0');
nfa_print_state2(debugf, state->out1, indent);
- /* shrink indent */
+ // shrink indent
indent->ga_len -= 3;
ga_append(indent, '\0');
}
fclose(debugf);
}
}
-#endif /* ENABLE_LOG */
-#endif /* DEBUG */
+#endif // ENABLE_LOG
+#endif // DEBUG
/*
* Parse r.e. @expr and convert it into postfix form.
return post_start;
}
-/* NB. Some of the code below is inspired by Russ's. */
+// NB. Some of the code below is inspired by Russ's.
/*
* Represents an NFA state plus zero or one or two arrows exiting.
* If c < 256, labeled arrow with character c to out.
*/
-static nfa_state_T *state_ptr; /* points to nfa_prog->state */
+static nfa_state_T *state_ptr; // points to nfa_prog->state
/*
* Allocate and initialize nfa_state_T.
* next state for this fragment.
*/
-/* Since the out pointers in the list are always
- * uninitialized, we use the pointers themselves
- * as storage for the Ptrlists. */
+// Since the out pointers in the list are always
+// uninitialized, we use the pointers themselves
+// as storage for the Ptrlists.
typedef union Ptrlist Ptrlist;
union Ptrlist
{
nfa_state_T *state = startstate;
int len = 0;
- /* detect looping in a NFA_SPLIT */
+ // detect looping in a NFA_SPLIT
if (depth > 4)
return -1;
{
case NFA_END_INVISIBLE:
case NFA_END_INVISIBLE_NEG:
- /* the end, return what we have */
+ // the end, return what we have
return len;
case NFA_SPLIT:
- /* two alternatives, use the maximum */
+ // two alternatives, use the maximum
l = nfa_max_width(state->out, depth + 1);
r = nfa_max_width(state->out1, depth + 1);
if (l < 0 || r < 0)
case NFA_ANY:
case NFA_START_COLL:
case NFA_START_NEG_COLL:
- /* matches some character, including composing chars */
+ // matches some character, including composing chars
if (enc_utf8)
len += MB_MAXBYTES;
else if (has_mbyte)
++len;
if (state->c != NFA_ANY)
{
- /* skip over the characters */
+ // skip over the characters
state = state->out1->out;
continue;
}
case NFA_WHITE:
case NFA_HEX:
case NFA_OCTAL:
- /* ascii */
+ // ascii
++len;
break;
case NFA_UPPER_IC:
case NFA_NUPPER_IC:
case NFA_ANY_COMPOSING:
- /* possibly non-ascii */
+ // possibly non-ascii
if (has_mbyte)
len += 3;
else
case NFA_START_INVISIBLE_NEG:
case NFA_START_INVISIBLE_BEFORE:
case NFA_START_INVISIBLE_BEFORE_NEG:
- /* zero-width, out1 points to the END state */
+ // zero-width, out1 points to the END state
state = state->out1->out;
continue;
#endif
case NFA_NEWL:
case NFA_SKIP:
- /* unknown width */
+ // unknown width
return -1;
case NFA_BOL:
case NFA_END_PATTERN:
case NFA_COMPOSING:
case NFA_END_COMPOSING:
- /* zero-width */
+ // zero-width
break;
default:
if (state->c < 0)
- /* don't know what this is */
+ // don't know what this is
return -1;
- /* normal character */
+ // normal character
len += MB_CHAR2LEN(state->c);
break;
}
- /* normal way to continue */
+ // normal way to continue
state = state->out;
}
- /* unrecognized, "cannot happen" */
+ // unrecognized, "cannot happen"
return -1;
}
switch (*p)
{
case NFA_CONCAT:
- /* Concatenation.
- * Pay attention: this operator does not exist in the r.e. itself
- * (it is implicit, really). It is added when r.e. is translated
- * to postfix form in re2post(). */
+ // Concatenation.
+ // Pay attention: this operator does not exist in the r.e. itself
+ // (it is implicit, really). It is added when r.e. is translated
+ // to postfix form in re2post().
if (nfa_calc_size == TRUE)
{
- /* nstate += 0; */
+ // nstate += 0;
break;
}
e2 = POP();
break;
case NFA_OR:
- /* Alternation */
+ // Alternation
if (nfa_calc_size == TRUE)
{
nstate++;
break;
case NFA_STAR:
- /* Zero or more, prefer more */
+ // Zero or more, prefer more
if (nfa_calc_size == TRUE)
{
nstate++;
break;
case NFA_STAR_NONGREEDY:
- /* Zero or more, prefer zero */
+ // Zero or more, prefer zero
if (nfa_calc_size == TRUE)
{
nstate++;
break;
case NFA_QUEST:
- /* one or zero atoms=> greedy match */
+ // one or zero atoms=> greedy match
if (nfa_calc_size == TRUE)
{
nstate++;
break;
case NFA_QUEST_NONGREEDY:
- /* zero or one atoms => non-greedy match */
+ // zero or one atoms => non-greedy match
if (nfa_calc_size == TRUE)
{
nstate++;
case NFA_END_COLL:
case NFA_END_NEG_COLL:
- /* On the stack is the sequence starting with NFA_START_COLL or
- * NFA_START_NEG_COLL and all possible characters. Patch it to
- * add the output to the start. */
+ // On the stack is the sequence starting with NFA_START_COLL or
+ // NFA_START_NEG_COLL and all possible characters. Patch it to
+ // add the output to the start.
if (nfa_calc_size == TRUE)
{
nstate++;
break;
case NFA_RANGE:
- /* Before this are two characters, the low and high end of a
- * range. Turn them into two states with MIN and MAX. */
+ // Before this are two characters, the low and high end of a
+ // range. Turn them into two states with MIN and MAX.
if (nfa_calc_size == TRUE)
{
- /* nstate += 0; */
+ // nstate += 0;
break;
}
e2 = POP();
break;
case NFA_EMPTY:
- /* 0-length, used in a repetition with max/min count of 0 */
+ // 0-length, used in a repetition with max/min count of 0
if (nfa_calc_size == TRUE)
{
nstate++;
{
int n;
- /* \%[abc] implemented as:
- * NFA_SPLIT
- * +-CHAR(a)
- * | +-NFA_SPLIT
- * | +-CHAR(b)
- * | | +-NFA_SPLIT
- * | | +-CHAR(c)
- * | | | +-next
- * | | +- next
- * | +- next
- * +- next
- */
- n = *++p; /* get number of characters */
+ // \%[abc] implemented as:
+ // NFA_SPLIT
+ // +-CHAR(a)
+ // | +-NFA_SPLIT
+ // | +-CHAR(b)
+ // | | +-NFA_SPLIT
+ // | | +-CHAR(c)
+ // | | | +-next
+ // | | +- next
+ // | +- next
+ // +- next
+ n = *++p; // get number of characters
if (nfa_calc_size == TRUE)
{
nstate += n;
break;
}
- s = NULL; /* avoid compiler warning */
- e1.out = NULL; /* stores list with out1's */
- s1 = NULL; /* previous NFA_SPLIT to connect to */
+ s = NULL; // avoid compiler warning
+ e1.out = NULL; // stores list with out1's
+ s1 = NULL; // previous NFA_SPLIT to connect to
while (n-- > 0)
{
- e = POP(); /* get character */
+ e = POP(); // get character
s = alloc_state(NFA_SPLIT, e.start, NULL);
if (s == NULL)
goto theend;
start_state = NFA_START_INVISIBLE_BEFORE_NEG;
end_state = NFA_END_INVISIBLE_NEG;
break;
- default: /* NFA_PREV_ATOM_LIKE_PATTERN: */
+ default: // NFA_PREV_ATOM_LIKE_PATTERN:
start_state = NFA_START_PATTERN;
end_state = NFA_END_PATTERN;
break;
}
if (before)
- n = *++p; /* get the count */
+ n = *++p; // get the count
- /* The \@= operator: match the preceding atom with zero width.
- * The \@! operator: no match for the preceding atom.
- * The \@<= operator: match for the preceding atom.
- * The \@<! operator: no match for the preceding atom.
- * Surrounds the preceding atom with START_INVISIBLE and
- * END_INVISIBLE, similarly to MOPEN. */
+ // The \@= operator: match the preceding atom with zero width.
+ // The \@! operator: no match for the preceding atom.
+ // The \@<= operator: match for the preceding atom.
+ // The \@<! operator: no match for the preceding atom.
+ // Surrounds the preceding atom with START_INVISIBLE and
+ // END_INVISIBLE, similarly to MOPEN.
if (nfa_calc_size == TRUE)
{
goto theend;
if (pattern)
{
- /* NFA_ZEND -> NFA_END_PATTERN -> NFA_SKIP -> what follows. */
+ // NFA_ZEND -> NFA_END_PATTERN -> NFA_SKIP -> what follows.
skip = alloc_state(NFA_SKIP, NULL, NULL);
if (skip == NULL)
goto theend;
if (before)
{
if (n <= 0)
- /* See if we can guess the maximum width, it avoids a
- * lot of pointless tries. */
+ // See if we can guess the maximum width, it avoids a
+ // lot of pointless tries.
n = nfa_max_width(e.start, 0);
- s->val = n; /* store the count */
+ s->val = n; // store the count
}
}
break;
}
- case NFA_COMPOSING: /* char with composing char */
+ case NFA_COMPOSING: // char with composing char
#if 0
- /* TODO */
+ // TODO
if (regflags & RF_ICOMBINE)
{
- /* use the base character only */
+ // use the base character only
}
#endif
- /* FALLTHROUGH */
+ // FALLTHROUGH
- case NFA_MOPEN: /* \( \) Submatch */
+ case NFA_MOPEN: // \( \) Submatch
case NFA_MOPEN1:
case NFA_MOPEN2:
case NFA_MOPEN3:
case NFA_MOPEN8:
case NFA_MOPEN9:
#ifdef FEAT_SYN_HL
- case NFA_ZOPEN: /* \z( \) Submatch */
+ case NFA_ZOPEN: // \z( \) Submatch
case NFA_ZOPEN1:
case NFA_ZOPEN2:
case NFA_ZOPEN3:
case NFA_ZOPEN8:
case NFA_ZOPEN9:
#endif
- case NFA_NOPEN: /* \%( \) "Invisible Submatch" */
+ case NFA_NOPEN: // \%( \) "Invisible Submatch"
if (nfa_calc_size == TRUE)
{
nstate += 2;
#endif
case NFA_COMPOSING: mclose = NFA_END_COMPOSING; break;
default:
- /* NFA_MOPEN, NFA_MOPEN1 .. NFA_MOPEN9 */
+ // NFA_MOPEN, NFA_MOPEN1 .. NFA_MOPEN9
mclose = *p + NSUBEXP;
break;
}
- /* Allow "NFA_MOPEN" as a valid postfix representation for
- * the empty regexp "". In this case, the NFA will be
- * NFA_MOPEN -> NFA_MCLOSE. Note that this also allows
- * empty groups of parenthesis, and empty mbyte chars */
+ // Allow "NFA_MOPEN" as a valid postfix representation for
+ // the empty regexp "". In this case, the NFA will be
+ // NFA_MOPEN -> NFA_MCLOSE. Note that this also allows
+ // empty groups of parenthesis, and empty mbyte chars
if (stackp == stack)
{
s = alloc_state(mopen, NULL, NULL);
break;
}
- /* At least one node was emitted before NFA_MOPEN, so
- * at least one node will be between NFA_MOPEN and NFA_MCLOSE */
+ // At least one node was emitted before NFA_MOPEN, so
+ // at least one node will be between NFA_MOPEN and NFA_MCLOSE
e = POP();
- s = alloc_state(mopen, e.start, NULL); /* `(' */
+ s = alloc_state(mopen, e.start, NULL); // `('
if (s == NULL)
goto theend;
- s1 = alloc_state(mclose, NULL, NULL); /* `)' */
+ s1 = alloc_state(mclose, NULL, NULL); // `)'
if (s1 == NULL)
goto theend;
patch(e.out, s1);
if (mopen == NFA_COMPOSING)
- /* COMPOSING->out1 = END_COMPOSING */
+ // COMPOSING->out1 = END_COMPOSING
patch(list1(&s->out1), s1);
PUSH(frag(s, list1(&s1->out)));
case NFA_MARK_GT:
case NFA_MARK_LT:
{
- int n = *++p; /* lnum, col or mark name */
+ int n = *++p; // lnum, col or mark name
if (nfa_calc_size == TRUE)
{
case NFA_ZSTART:
case NFA_ZEND:
default:
- /* Operands */
+ // Operands
if (nfa_calc_size == TRUE)
{
nstate++;
PUSH(frag(s, list1(&s->out)));
break;
- } /* switch(*p) */
+ } // switch(*p)
- } /* for(p = postfix; *p; ++p) */
+ } // for(p = postfix; *p; ++p)
if (nfa_calc_size == TRUE)
{
nstate++;
- goto theend; /* Return value when counting size is ignored anyway */
+ goto theend; // Return value when counting size is ignored anyway
}
e = POP();
EMSG_RET_NULL(_("E876: (NFA regexp) Not enough space to store the whole NFA "));
}
- matchstate = &state_ptr[istate++]; /* the match state */
+ matchstate = &state_ptr[istate++]; // the match state
matchstate->c = NFA_MATCH;
matchstate->out = matchstate->out1 = NULL;
matchstate->id = 0;
{
int directly;
- /* Do it directly when what follows is possibly the end of the
- * match. */
+ // Do it directly when what follows is possibly the end of the
+ // match.
if (match_follows(prog->state[i].out1->out, 0))
directly = TRUE;
else
int ch_invisible = failure_chance(prog->state[i].out, 0);
int ch_follows = failure_chance(prog->state[i].out1->out, 0);
- /* Postpone when the invisible match is expensive or has a
- * lower chance of failing. */
+ // Postpone when the invisible match is expensive or has a
+ // lower chance of failing.
if (c == NFA_START_INVISIBLE_BEFORE
|| c == NFA_START_INVISIBLE_BEFORE_NEG)
{
- /* "before" matches are very expensive when
- * unbounded, always prefer what follows then,
- * unless what follows will always match.
- * Otherwise strongly prefer what follows. */
+ // "before" matches are very expensive when
+ // unbounded, always prefer what follows then,
+ // unless what follows will always match.
+ // Otherwise strongly prefer what follows.
if (prog->state[i].val <= 0 && ch_follows > 0)
directly = FALSE;
else
}
else
{
- /* normal invisible, first do the one with the
- * highest failure chance */
+ // normal invisible, first do the one with the
+ // highest failure chance
directly = ch_follows < ch_invisible;
}
}
if (directly)
- /* switch to the _FIRST state */
+ // switch to the _FIRST state
++prog->state[i].c;
}
}
}
-/****************************************************************
- * NFA execution code.
- ****************************************************************/
+/////////////////////////////////////////////////////////////////
+// NFA execution code.
+/////////////////////////////////////////////////////////////////
typedef struct
{
- int in_use; /* number of subexpr with useful info */
+ int in_use; // number of subexpr with useful info
- /* When REG_MULTI is TRUE list.multi is used, otherwise list.line. */
+ // When REG_MULTI is TRUE list.multi is used, otherwise list.line.
union
{
struct multipos
typedef struct
{
- regsub_T norm; /* \( .. \) matches */
+ regsub_T norm; // \( .. \) matches
#ifdef FEAT_SYN_HL
- regsub_T synt; /* \z( .. \) matches */
+ regsub_T synt; // \z( .. \) matches
#endif
} regsubs_T;
-/* nfa_pim_T stores a Postponed Invisible Match. */
+// nfa_pim_T stores a Postponed Invisible Match.
typedef struct nfa_pim_S nfa_pim_T;
struct nfa_pim_S
{
- int result; /* NFA_PIM_*, see below */
- nfa_state_T *state; /* the invisible match start state */
- regsubs_T subs; /* submatch info, only party used */
+ int result; // NFA_PIM_*, see below
+ nfa_state_T *state; // the invisible match start state
+ regsubs_T subs; // submatch info, only party used
union
{
lpos_T pos;
char_u *ptr;
- } end; /* where the match must end */
+ } end; // where the match must end
};
-/* Values for done in nfa_pim_T. */
-#define NFA_PIM_UNUSED 0 /* pim not used */
-#define NFA_PIM_TODO 1 /* pim not done yet */
-#define NFA_PIM_MATCH 2 /* pim executed, matches */
-#define NFA_PIM_NOMATCH 3 /* pim executed, no match */
+// Values for done in nfa_pim_T.
+#define NFA_PIM_UNUSED 0 // pim not used
+#define NFA_PIM_TODO 1 // pim not done yet
+#define NFA_PIM_MATCH 2 // pim executed, matches
+#define NFA_PIM_NOMATCH 3 // pim executed, no match
-/* nfa_thread_T contains execution information of a NFA state */
+// nfa_thread_T contains execution information of a NFA state
typedef struct
{
nfa_state_T *state;
int count;
- nfa_pim_T pim; /* if pim.result != NFA_PIM_UNUSED: postponed
- * invisible match */
- regsubs_T subs; /* submatch info, only party used */
+ nfa_pim_T pim; // if pim.result != NFA_PIM_UNUSED: postponed
+ // invisible match
+ regsubs_T subs; // submatch info, only party used
} nfa_thread_T;
-/* nfa_list_T contains the alternative NFA execution states. */
+// nfa_list_T contains the alternative NFA execution states.
typedef struct
{
- nfa_thread_T *t; /* allocated array of states */
- int n; /* nr of states currently in "t" */
- int len; /* max nr of states in "t" */
- int id; /* ID of the list */
- int has_pim; /* TRUE when any state has a PIM */
+ nfa_thread_T *t; // allocated array of states
+ int n; // nr of states currently in "t"
+ int len; // max nr of states in "t"
+ int id; // ID of the list
+ int has_pim; // TRUE when any state has a PIM
} nfa_list_T;
#ifdef ENABLE_LOG
#endif
-/* Used during execution: whether a match has been found. */
+// Used during execution: whether a match has been found.
static int nfa_match;
#ifdef FEAT_RELTIME
static proftime_T *nfa_time_limit;
clear_sub(regsub_T *sub)
{
if (REG_MULTI)
- /* Use 0xff to set lnum to -1 */
+ // Use 0xff to set lnum to -1
vim_memset(sub->list.multi, 0xff,
sizeof(struct multipos) * rex.nfa_nsubexpr);
else
to->in_use = from->in_use;
if (from->in_use > 0)
{
- /* Copy the match start and end positions. */
+ // Copy the match start and end positions.
if (REG_MULTI)
mch_memmove(&to->list.multi[0],
&from->list.multi[0],
to->in_use = from->in_use;
if (from->in_use > 1)
{
- /* Copy the match start and end positions. */
+ // Copy the match start and end positions.
if (REG_MULTI)
mch_memmove(&to->list.multi[1],
&from->list.multi[1],
*/
static int
has_state_with_pos(
- nfa_list_T *l, /* runtime state list */
- nfa_state_T *state, /* state to update */
- regsubs_T *subs, /* pointers to subexpressions */
- nfa_pim_T *pim) /* postponed match or NULL */
+ nfa_list_T *l, // runtime state list
+ nfa_state_T *state, // state to update
+ regsubs_T *subs, // pointers to subexpressions
+ nfa_pim_T *pim) // postponed match or NULL
{
nfa_thread_T *thread;
int i;
int two_unused = (two == NULL || two->result == NFA_PIM_UNUSED);
if (one_unused)
- /* one is unused: equal when two is also unused */
+ // one is unused: equal when two is also unused
return two_unused;
if (two_unused)
- /* one is used and two is not: not equal */
+ // one is used and two is not: not equal
return FALSE;
- /* compare the state id */
+ // compare the state id
if (one->state->id != two->state->id)
return FALSE;
- /* compare the position */
+ // compare the position
if (REG_MULTI)
return one->end.pos.lnum == two->end.pos.lnum
&& one->end.pos.col == two->end.pos.col;
{
nfa_state_T *state = startstate;
- /* avoid too much recursion */
+ // avoid too much recursion
if (depth > 10)
return FALSE;
case NFA_START_INVISIBLE_BEFORE_NEG:
case NFA_START_INVISIBLE_BEFORE_NEG_FIRST:
case NFA_COMPOSING:
- /* skip ahead to next state */
+ // skip ahead to next state
state = state->out1->out;
continue;
case NFA_START_COLL:
case NFA_START_NEG_COLL:
case NFA_NEWL:
- /* state will advance input */
+ // state will advance input
return FALSE;
default:
if (state->c > 0)
- /* state will advance input */
+ // state will advance input
return FALSE;
- /* Others: zero-width or possibly zero-width, might still find
- * a match at the same position, keep looking. */
+ // Others: zero-width or possibly zero-width, might still find
+ // a match at the same position, keep looking.
break;
}
state = state->out;
*/
static int
state_in_list(
- nfa_list_T *l, /* runtime state list */
- nfa_state_T *state, /* state to update */
- regsubs_T *subs) /* pointers to subexpressions */
+ nfa_list_T *l, // runtime state list
+ nfa_state_T *state, // state to update
+ regsubs_T *subs) // pointers to subexpressions
{
if (state->lastlist[nfa_ll_index] == l->id)
{
return FALSE;
}
-/* Offset used for "off" by addstate_here(). */
+// Offset used for "off" by addstate_here().
#define ADDSTATE_HERE_OFFSET 10
/*
*/
static regsubs_T *
addstate(
- nfa_list_T *l, /* runtime state list */
- nfa_state_T *state, /* state to update */
- regsubs_T *subs_arg, /* pointers to subexpressions */
- nfa_pim_T *pim, /* postponed look-behind match */
- int off_arg) /* byte offset, when -1 go to next line */
+ nfa_list_T *l, // runtime state list
+ nfa_state_T *state, // state to update
+ regsubs_T *subs_arg, // pointers to subexpressions
+ nfa_pim_T *pim, // postponed look-behind match
+ int off_arg) // byte offset, when -1 go to next line
{
int subidx;
int off = off_arg;
case NFA_ZEND:
case NFA_SPLIT:
case NFA_EMPTY:
- /* These nodes are not added themselves but their "out" and/or
- * "out1" may be added below. */
+ // These nodes are not added themselves but their "out" and/or
+ // "out1" may be added below.
break;
case NFA_BOL:
case NFA_BOF:
- /* "^" won't match past end-of-line, don't bother trying.
- * Except when at the end of the line, or when we are going to the
- * next line for a look-behind match. */
+ // "^" won't match past end-of-line, don't bother trying.
+ // Except when at the end of the line, or when we are going to the
+ // next line for a look-behind match.
if (rex.input > rex.line
&& *rex.input != NUL
&& (nfa_endp == NULL
|| !REG_MULTI
|| rex.lnum == nfa_endp->se_u.pos.lnum))
goto skip_add;
- /* FALLTHROUGH */
+ // FALLTHROUGH
case NFA_MOPEN1:
case NFA_MOPEN2:
#endif
case NFA_NOPEN:
case NFA_ZSTART:
- /* These nodes need to be added so that we can bail out when it
- * was added to this list before at the same position to avoid an
- * endless loop for "\(\)*" */
+ // These nodes need to be added so that we can bail out when it
+ // was added to this list before at the same position to avoid an
+ // endless loop for "\(\)*"
default:
if (state->lastlist[nfa_ll_index] == l->id && state->c != NFA_SKIP)
{
- /* This state is already in the list, don't add it again,
- * unless it is an MOPEN that is used for a backreference or
- * when there is a PIM. For NFA_MATCH check the position,
- * lower position is preferred. */
+ // This state is already in the list, don't add it again,
+ // unless it is an MOPEN that is used for a backreference or
+ // when there is a PIM. For NFA_MATCH check the position,
+ // lower position is preferred.
if (!rex.nfa_has_backref && pim == NULL && !l->has_pim
&& state->c != NFA_MATCH)
{
- /* When called from addstate_here() do insert before
- * existing states. */
+ // When called from addstate_here() do insert before
+ // existing states.
if (add_here)
{
for (k = 0; k < l->n && k < listindex; ++k)
}
}
- /* Do not add the state again when it exists with the same
- * positions. */
+ // Do not add the state again when it exists with the same
+ // positions.
if (has_state_with_pos(l, state, subs, pim))
goto skip_add;
}
}
if (subs != &temp_subs)
{
- /* "subs" may point into the current array, need to make a
- * copy before it becomes invalid. */
+ // "subs" may point into the current array, need to make a
+ // copy before it becomes invalid.
copy_sub(&temp_subs.norm, &subs->norm);
#ifdef FEAT_SYN_HL
if (rex.nfa_has_zsubexpr)
l->len = newlen;
}
- /* add the state to the list */
+ // add the state to the list
state->lastlist[nfa_ll_index] = l->id;
thread = &l->t[l->n++];
thread->state = state;
break;
case NFA_SPLIT:
- /* order matters here */
+ // order matters here
subs = addstate(l, state->out, subs, pim, off_arg);
subs = addstate(l, state->out1, subs, pim, off_arg);
break;
sub = &subs->norm;
}
- /* avoid compiler warnings */
+ // avoid compiler warnings
save_ptr = NULL;
vim_memset(&save_multipos, 0, sizeof(save_multipos));
- /* Set the position (with "off" added) in the subexpression. Save
- * and restore it when it was in use. Otherwise fill any gap. */
+ // Set the position (with "off" added) in the subexpression. Save
+ // and restore it when it was in use. Otherwise fill any gap.
if (REG_MULTI)
{
if (subidx < sub->in_use)
subs = addstate(l, state->out, subs, pim, off_arg);
break;
}
- /* FALLTHROUGH */
+ // FALLTHROUGH
case NFA_MCLOSE1:
case NFA_MCLOSE2:
case NFA_MCLOSE3:
sub = &subs->norm;
}
- /* We don't fill in gaps here, there must have been an MOPEN that
- * has done that. */
+ // We don't fill in gaps here, there must have been an MOPEN that
+ // has done that.
save_in_use = sub->in_use;
if (sub->in_use <= subidx)
sub->in_use = subidx + 1;
sub->list.multi[subidx].end_col =
(colnr_T)(rex.input - rex.line + off);
}
- /* avoid compiler warnings */
+ // avoid compiler warnings
save_ptr = NULL;
}
else
{
save_ptr = sub->list.line[subidx].end;
sub->list.line[subidx].end = rex.input + off;
- /* avoid compiler warnings */
+ // avoid compiler warnings
vim_memset(&save_multipos, 0, sizeof(save_multipos));
}
subs = addstate(l, state->out, subs, pim, off_arg);
if (subs == NULL)
break;
- /* "subs" may have changed, need to set "sub" again */
+ // "subs" may have changed, need to set "sub" again
#ifdef FEAT_SYN_HL
if (state->c >= NFA_ZCLOSE && state->c <= NFA_ZCLOSE9)
sub = &subs->synt;
*/
static regsubs_T *
addstate_here(
- nfa_list_T *l, /* runtime state list */
- nfa_state_T *state, /* state to update */
- regsubs_T *subs, /* pointers to subexpressions */
- nfa_pim_T *pim, /* postponed look-behind match */
+ nfa_list_T *l, // runtime state list
+ nfa_state_T *state, // state to update
+ regsubs_T *subs, // pointers to subexpressions
+ nfa_pim_T *pim, // postponed look-behind match
int *ip)
{
int tlen = l->n;
int listidx = *ip;
regsubs_T *r;
- /* First add the state(s) at the end, so that we know how many there are.
- * Pass the listidx as offset (avoids adding another argument to
- * addstate(). */
+ // First add the state(s) at the end, so that we know how many there are.
+ // Pass the listidx as offset (avoids adding another argument to
+ // addstate().
r = addstate(l, state, subs, pim, -listidx - ADDSTATE_HERE_OFFSET);
if (r == NULL)
return NULL;
{
if (l->n + count - 1 >= l->len)
{
- /* not enough space to move the new states, reallocate the list
- * and move the states to the right position */
+ // not enough space to move the new states, reallocate the list
+ // and move the states to the right position
int newlen = l->len * 3 / 2 + 50;
size_t newsize = newlen * sizeof(nfa_thread_T);
nfa_thread_T *newl;
}
else
{
- /* make space for new states, then move them from the
- * end to the current position */
+ // make space for new states, then move them from the
+ // end to the current position
mch_memmove(&(l->t[listidx + count]),
&(l->t[listidx + 1]),
sizeof(nfa_thread_T) * (l->n - listidx - 1));
break;
default:
- /* should not be here :P */
+ // should not be here :P
siemsg(_(e_ill_char_class), class);
return FAIL;
}
*/
static int
match_backref(
- regsub_T *sub, /* pointers to subexpressions */
+ regsub_T *sub, // pointers to subexpressions
int subidx,
- int *bytelen) /* out: length of match in bytes */
+ int *bytelen) // out: length of match in bytes
{
int len;
if (sub->in_use <= subidx)
{
retempty:
- /* backref was not set, match an empty string */
+ // backref was not set, match an empty string
*bytelen = 0;
return TRUE;
}
static int
match_zref(
int subidx,
- int *bytelen) /* out: length of match in bytes */
+ int *bytelen) // out: length of match in bytes
{
int len;
cleanup_zsubexpr();
if (re_extmatch_in == NULL || re_extmatch_in->matches[subidx] == NULL)
{
- /* backref was not set, match an empty string */
+ // backref was not set, match an empty string
*bytelen = 0;
return TRUE;
}
int i;
nfa_state_T *p;
- /* Order in the list is reverse, it's a bit faster that way. */
+ // Order in the list is reverse, it's a bit faster that way.
p = &prog->state[0];
for (i = prog->nstate; --i >= 0; )
{
if (pim != NULL)
{
- /* start at the position where the postponed match was */
+ // start at the position where the postponed match was
if (REG_MULTI)
rex.input = rex.line + pim->end.pos.col;
else
|| state->c == NFA_START_INVISIBLE_BEFORE_NEG
|| state->c == NFA_START_INVISIBLE_BEFORE_NEG_FIRST)
{
- /* The recursive match must end at the current position. When "pim" is
- * not NULL it specifies the current position. */
+ // The recursive match must end at the current position. When "pim" is
+ // not NULL it specifies the current position.
endposp = &endpos;
if (REG_MULTI)
{
endpos.se_u.ptr = pim->end.ptr;
}
- /* Go back the specified number of bytes, or as far as the
- * start of the previous line, to try matching "\@<=" or
- * not matching "\@<!". This is very inefficient, limit the number of
- * bytes if possible. */
+ // Go back the specified number of bytes, or as far as the
+ // start of the previous line, to try matching "\@<=" or
+ // not matching "\@<!". This is very inefficient, limit the number of
+ // bytes if possible.
if (state->val <= 0)
{
if (REG_MULTI)
{
rex.line = reg_getline(--rex.lnum);
if (rex.line == NULL)
- /* can't go before the first line */
+ // can't go before the first line
rex.line = reg_getline(++rex.lnum);
}
rex.input = rex.line;
{
if (REG_MULTI && (int)(rex.input - rex.line) < state->val)
{
- /* Not enough bytes in this line, go to end of
- * previous line. */
+ // Not enough bytes in this line, go to end of
+ // previous line.
rex.line = reg_getline(--rex.lnum);
if (rex.line == NULL)
{
- /* can't go before the first line */
+ // can't go before the first line
rex.line = reg_getline(++rex.lnum);
rex.input = rex.line;
}
fclose(log_fd);
log_fd = NULL;
#endif
- /* Have to clear the lastlist field of the NFA nodes, so that
- * nfa_regmatch() and addstate() can run properly after recursion. */
+ // Have to clear the lastlist field of the NFA nodes, so that
+ // nfa_regmatch() and addstate() can run properly after recursion.
if (nfa_ll_index == 1)
{
- /* Already calling nfa_regmatch() recursively. Save the lastlist[1]
- * values and clear them. */
+ // Already calling nfa_regmatch() recursively. Save the lastlist[1]
+ // values and clear them.
if (*listids == NULL || *listids_len < prog->nstate)
{
vim_free(*listids);
}
nfa_save_listids(prog, *listids);
need_restore = TRUE;
- /* any value of rex.nfa_listid will do */
+ // any value of rex.nfa_listid will do
}
else
{
- /* First recursive nfa_regmatch() call, switch to the second lastlist
- * entry. Make sure rex.nfa_listid is different from a previous
- * recursive call, because some states may still have this ID. */
+ // First recursive nfa_regmatch() call, switch to the second lastlist
+ // entry. Make sure rex.nfa_listid is different from a previous
+ // recursive call, because some states may still have this ID.
++nfa_ll_index;
if (rex.nfa_listid <= rex.nfa_alt_listid)
rex.nfa_listid = rex.nfa_alt_listid;
}
- /* Call nfa_regmatch() to check if the current concat matches at this
- * position. The concat ends with the node NFA_END_INVISIBLE */
+ // Call nfa_regmatch() to check if the current concat matches at this
+ // position. The concat ends with the node NFA_END_INVISIBLE
nfa_endp = endposp;
result = nfa_regmatch(prog, state->out, submatch, m);
rex.nfa_alt_listid = rex.nfa_listid;
}
- /* restore position in input text */
+ // restore position in input text
rex.lnum = save_reglnum;
if (REG_MULTI)
rex.line = reg_getline(rex.lnum);
int c = state->c;
int l, r;
- /* detect looping */
+ // detect looping
if (depth > 4)
return 1;
{
case NFA_SPLIT:
if (state->out->c == NFA_SPLIT || state->out1->c == NFA_SPLIT)
- /* avoid recursive stuff */
+ // avoid recursive stuff
return 1;
- /* two alternatives, use the lowest failure chance */
+ // two alternatives, use the lowest failure chance
l = failure_chance(state->out, depth + 1);
r = failure_chance(state->out1, depth + 1);
return l < r ? l : r;
case NFA_ANY:
- /* matches anything, unlikely to fail */
+ // matches anything, unlikely to fail
return 1;
case NFA_MATCH:
case NFA_MCLOSE:
case NFA_ANY_COMPOSING:
- /* empty match works always */
+ // empty match works always
return 0;
case NFA_START_INVISIBLE:
case NFA_START_INVISIBLE_BEFORE_NEG:
case NFA_START_INVISIBLE_BEFORE_NEG_FIRST:
case NFA_START_PATTERN:
- /* recursive regmatch is expensive, use low failure chance */
+ // recursive regmatch is expensive, use low failure chance
return 5;
case NFA_BOL:
case NFA_ZREF8:
case NFA_ZREF9:
#endif
- /* backreferences don't match in many places */
+ // backreferences don't match in many places
return 94;
case NFA_LNUM_GT:
case NFA_MARK_GT:
case NFA_MARK_LT:
case NFA_VISUAL:
- /* before/after positions don't match very often */
+ // before/after positions don't match very often
return 85;
case NFA_LNUM:
case NFA_COL:
case NFA_VCOL:
case NFA_MARK:
- /* specific positions rarely match */
+ // specific positions rarely match
return 98;
case NFA_COMPOSING:
default:
if (c > 0)
- /* character match fails often */
+ // character match fails often
return 95;
}
- /* something else, includes character classes */
+ // something else, includes character classes
return 50;
}
{
char_u *s;
- /* Used often, do some work to avoid call overhead. */
+ // Used often, do some work to avoid call overhead.
if (!rex.reg_ic && !has_mbyte)
s = vim_strbyte(rex.line + *colp, c);
else
for (;;)
{
match = TRUE;
- len2 = MB_CHAR2LEN(regstart); /* skip regstart */
+ len2 = MB_CHAR2LEN(regstart); // skip regstart
for (len1 = 0; match_text[len1] != NUL; len1 += MB_CHAR2LEN(c1))
{
c1 = PTR2CHAR(match_text + len1);
len2 += MB_CHAR2LEN(c2);
}
if (match
- /* check that no composing char follows */
+ // check that no composing char follows
&& !(enc_utf8
&& utf_iscomposing(PTR2CHAR(rex.line + col + len2))))
{
return 1L;
}
- /* Try finding regstart after the current match. */
- col += MB_CHAR2LEN(regstart); /* skip regstart */
+ // Try finding regstart after the current match.
+ col += MB_CHAR2LEN(regstart); // skip regstart
if (skip_to_start(regstart, &col) == FAIL)
break;
}
FILE *debug;
#endif
- /* Some patterns may take a long time to match, especially when using
- * recursive_regmatch(). Allow interrupting them with CTRL-C. */
+ // Some patterns may take a long time to match, especially when using
+ // recursive_regmatch(). Allow interrupting them with CTRL-C.
fast_breakcheck();
if (got_int)
return FALSE;
#endif
nfa_match = FALSE;
- /* Allocate memory for the lists of nodes. */
+ // Allocate memory for the lists of nodes.
size = (prog->nstate + 1) * sizeof(nfa_thread_T);
list[0].t = alloc(size);
#endif
thislist->id = rex.nfa_listid + 1;
- /* Inline optimized code for addstate(thislist, start, m, 0) if we know
- * it's the first MOPEN. */
+ // Inline optimized code for addstate(thislist, start, m, 0) if we know
+ // it's the first MOPEN.
if (toplevel)
{
if (REG_MULTI)
go_to_nextline = FALSE;
}
- /* swap lists */
+ // swap lists
thislist = &list[flag];
nextlist = &list[flag ^= 1];
- nextlist->n = 0; /* clear nextlist */
+ nextlist->n = 0; // clear nextlist
nextlist->has_pim = FALSE;
++rex.nfa_listid;
if (prog->re_engine == AUTOMATIC_ENGINE
# endif
))
{
- /* too many states, retry with old engine */
+ // too many states, retry with old engine
nfa_match = NFA_TOO_EXPENSIVE;
goto theend;
}
if (thislist->n == 0)
break;
- /* compute nextlist */
+ // compute nextlist
for (listidx = 0; listidx < thislist->n; ++listidx)
{
- /* If the list gets very long there probably is something wrong.
- * At least allow interrupting with CTRL-C. */
+ // If the list gets very long there probably is something wrong.
+ // At least allow interrupting with CTRL-C.
fast_breakcheck();
if (got_int)
break;
{
case NFA_MATCH:
{
- /* If the match ends before a composing characters and
- * rex.reg_icombine is not set, that is not really a match. */
+ // If the match ends before a composing characters and
+ // rex.reg_icombine is not set, that is not really a match.
if (enc_utf8 && !rex.reg_icombine && utf_iscomposing(curc))
break;
#ifdef ENABLE_LOG
log_subsexpr(&t->subs);
#endif
- /* Found the left-most longest match, do not look at any other
- * states at this position. When the list of states is going
- * to be empty quit without advancing, so that "rex.input" is
- * correct. */
+ // Found the left-most longest match, do not look at any other
+ // states at this position. When the list of states is going
+ // to be empty quit without advancing, so that "rex.input" is
+ // correct.
if (nextlist->n == 0)
clen = 0;
goto nextchar;
(int)(nfa_endp->se_u.ptr - rex.input));
}
#endif
- /* If "nfa_endp" is set it's only a match if it ends at
- * "nfa_endp" */
+ // If "nfa_endp" is set it's only a match if it ends at
+ // "nfa_endp"
if (nfa_endp != NULL && (REG_MULTI
? (rex.lnum != nfa_endp->se_u.pos.lnum
|| (int)(rex.input - rex.line)
: rex.input != nfa_endp->se_u.ptr))
break;
- /* do not set submatches for \@! */
+ // do not set submatches for \@!
if (t->state->c != NFA_END_INVISIBLE_NEG)
{
copy_sub(&m->norm, &t->subs.norm);
log_subsexpr(m);
#endif
nfa_match = TRUE;
- /* See comment above at "goto nextchar". */
+ // See comment above at "goto nextchar".
if (nextlist->n == 0)
clen = 0;
goto nextchar;
failure_chance(t->state->out, 0),
failure_chance(t->state->out1->out, 0));
#endif
- /* Do it directly if there already is a PIM or when
- * nfa_postprocess() detected it will work better. */
+ // Do it directly if there already is a PIM or when
+ // nfa_postprocess() detected it will work better.
if (t->pim.result != NFA_PIM_UNUSED
|| t->state->c == NFA_START_INVISIBLE_FIRST
|| t->state->c == NFA_START_INVISIBLE_NEG_FIRST
{
int in_use = m->norm.in_use;
- /* Copy submatch info for the recursive call, opposite
- * of what happens on success below. */
+ // Copy submatch info for the recursive call, opposite
+ // of what happens on success below.
copy_sub_off(&m->norm, &t->subs.norm);
#ifdef FEAT_SYN_HL
if (rex.nfa_has_zsubexpr)
goto theend;
}
- /* for \@! and \@<! it is a match when the result is
- * FALSE */
+ // for \@! and \@<! it is a match when the result is
+ // FALSE
if (result != (t->state->c == NFA_START_INVISIBLE_NEG
|| t->state->c == NFA_START_INVISIBLE_NEG_FIRST
|| t->state->c
|| t->state->c
== NFA_START_INVISIBLE_BEFORE_NEG_FIRST))
{
- /* Copy submatch info from the recursive call */
+ // Copy submatch info from the recursive call
copy_sub_off(&t->subs.norm, &m->norm);
#ifdef FEAT_SYN_HL
if (rex.nfa_has_zsubexpr)
copy_sub_off(&t->subs.synt, &m->synt);
#endif
- /* If the pattern has \ze and it matched in the
- * sub pattern, use it. */
+ // If the pattern has \ze and it matched in the
+ // sub pattern, use it.
copy_ze_off(&t->subs.norm, &m->norm);
- /* t->state->out1 is the corresponding
- * END_INVISIBLE node; Add its out to the current
- * list (zero-width match). */
+ // t->state->out1 is the corresponding
+ // END_INVISIBLE node; Add its out to the current
+ // list (zero-width match).
add_here = TRUE;
add_state = t->state->out1->out;
}
else
pim.end.ptr = rex.input;
- /* t->state->out1 is the corresponding END_INVISIBLE
- * node; Add its out to the current list (zero-width
- * match). */
+ // t->state->out1 is the corresponding END_INVISIBLE
+ // node; Add its out to the current list (zero-width
+ // match).
if (addstate_here(thislist, t->state->out1->out,
&t->subs, &pim, &listidx) == NULL)
{
int skip_lid = 0;
#endif
- /* There is no point in trying to match the pattern if the
- * output state is not going to be added to the list. */
+ // There is no point in trying to match the pattern if the
+ // output state is not going to be added to the list.
if (state_in_list(nextlist, t->state->out1->out, &t->subs))
{
skip = t->state->out1->out;
#endif
break;
}
- /* Copy submatch info to the recursive call, opposite of what
- * happens afterwards. */
+ // Copy submatch info to the recursive call, opposite of what
+ // happens afterwards.
copy_sub_off(&m->norm, &t->subs.norm);
#ifdef FEAT_SYN_HL
if (rex.nfa_has_zsubexpr)
copy_sub_off(&m->synt, &t->subs.synt);
#endif
- /* First try matching the pattern. */
+ // First try matching the pattern.
result = recursive_regmatch(t->state, NULL, prog,
submatch, m, &listids, &listids_len);
if (result == NFA_TOO_EXPENSIVE)
fprintf(log_fd, "NFA_START_PATTERN matches:\n");
log_subsexpr(m);
#endif
- /* Copy submatch info from the recursive call */
+ // Copy submatch info from the recursive call
copy_sub_off(&t->subs.norm, &m->norm);
#ifdef FEAT_SYN_HL
if (rex.nfa_has_zsubexpr)
copy_sub_off(&t->subs.synt, &m->synt);
#endif
- /* Now we need to skip over the matched text and then
- * continue with what follows. */
+ // Now we need to skip over the matched text and then
+ // continue with what follows.
if (REG_MULTI)
- /* TODO: multi-line match */
+ // TODO: multi-line match
bytelen = m->norm.list.multi[0].end_col
- (int)(rex.input - rex.line);
else
#endif
if (bytelen == 0)
{
- /* empty match, output of corresponding
- * NFA_END_PATTERN/NFA_SKIP to be used at current
- * position */
+ // empty match, output of corresponding
+ // NFA_END_PATTERN/NFA_SKIP to be used at current
+ // position
add_here = TRUE;
add_state = t->state->out1->out->out;
}
else if (bytelen <= clen)
{
- /* match current character, output of corresponding
- * NFA_END_PATTERN to be used at next position. */
+ // match current character, output of corresponding
+ // NFA_END_PATTERN to be used at next position.
add_state = t->state->out1->out->out;
add_off = clen;
}
else
{
- /* skip over the matched characters, set character
- * count in NFA_SKIP */
+ // skip over the matched characters, set character
+ // count in NFA_SKIP
add_state = t->state->out1->out;
add_off = bytelen;
add_count = bytelen - clen;
{
int this_class;
- /* Get class of current and previous char (if it exists). */
+ // Get class of current and previous char (if it exists).
this_class = mb_get_class_buf(rex.input, rex.reg_buf);
if (this_class <= 1)
result = FALSE;
{
int this_class, prev_class;
- /* Get class of current and previous char (if it exists). */
+ // Get class of current and previous char (if it exists).
this_class = mb_get_class_buf(rex.input, rex.reg_buf);
prev_class = reg_prev_class();
if (this_class == prev_class
len = 0;
if (utf_iscomposing(sta->c))
{
- /* Only match composing character(s), ignore base
- * character. Used for ".{composing}" and "{composing}"
- * (no preceding character). */
+ // Only match composing character(s), ignore base
+ // character. Used for ".{composing}" and "{composing}"
+ // (no preceding character).
len += mb_char2len(mc);
}
if (rex.reg_icombine && len == 0)
{
- /* If \Z was present, then ignore composing characters.
- * When ignoring the base character this always matches. */
+ // If \Z was present, then ignore composing characters.
+ // When ignoring the base character this always matches.
if (sta->c != curc)
result = FAIL;
else
sta = sta->out;
}
- /* Check base character matches first, unless ignored. */
+ // Check base character matches first, unless ignored.
else if (len > 0 || mc == sta->c)
{
if (len == 0)
sta = sta->out;
}
- /* We don't care about the order of composing characters.
- * Get them into cchars[] first. */
+ // We don't care about the order of composing characters.
+ // Get them into cchars[] first.
while (len < clen)
{
mc = mb_ptr2char(rex.input + len);
break;
}
- /* Check that each composing char in the pattern matches a
- * composing char in the text. We do not check if all
- * composing chars are matched. */
+ // Check that each composing char in the pattern matches a
+ // composing char in the text. We do not check if all
+ // composing chars are matched.
result = OK;
while (sta->c != NFA_END_COMPOSING)
{
else
result = FAIL;
- end = t->state->out1; /* NFA_END_COMPOSING */
+ end = t->state->out1; // NFA_END_COMPOSING
ADD_STATE_IF_MATCH(end);
break;
}
&& rex.lnum <= rex.reg_maxline)
{
go_to_nextline = TRUE;
- /* Pass -1 for the offset, which means taking the position
- * at the start of the next line. */
+ // Pass -1 for the offset, which means taking the position
+ // at the start of the next line.
add_state = t->state->out;
add_off = -1;
}
else if (curc == '\n' && rex.reg_line_lbr)
{
- /* match \n as if it is an ordinary character */
+ // match \n as if it is an ordinary character
add_state = t->state->out;
add_off = 1;
}
case NFA_START_COLL:
case NFA_START_NEG_COLL:
{
- /* What follows is a list of characters, until NFA_END_COLL.
- * One of them must match or none of them must match. */
+ // What follows is a list of characters, until NFA_END_COLL.
+ // One of them must match or none of them must match.
nfa_state_T *state;
int result_if_matched;
int c1, c2;
- /* Never match EOL. If it's part of the collection it is added
- * as a separate state with an OR. */
+ // Never match EOL. If it's part of the collection it is added
+ // as a separate state with an OR.
if (curc == NUL)
break;
if (state->c == NFA_RANGE_MIN)
{
c1 = state->val;
- state = state->out; /* advance to NFA_RANGE_MAX */
+ state = state->out; // advance to NFA_RANGE_MAX
c2 = state->val;
#ifdef ENABLE_LOG
fprintf(log_fd, "NFA_RANGE_MIN curc=%d c1=%d c2=%d\n",
}
if (result)
{
- /* next state is in out of the NFA_END_COLL, out1 of
- * START points to the END state */
+ // next state is in out of the NFA_END_COLL, out1 of
+ // START points to the END state
add_state = t->state->out1->out;
add_off = clen;
}
}
case NFA_ANY:
- /* Any char except '\0', (end of input) does not match. */
+ // Any char except '\0', (end of input) does not match.
if (curc > 0)
{
add_state = t->state->out;
break;
case NFA_ANY_COMPOSING:
- /* On a composing character skip over it. Otherwise do
- * nothing. Always matches. */
+ // On a composing character skip over it. Otherwise do
+ // nothing. Always matches.
if (enc_utf8 && utf_iscomposing(curc))
{
add_off = clen;
/*
* Character classes like \a for alpha, \d for digit etc.
*/
- case NFA_IDENT: /* \i */
+ case NFA_IDENT: // \i
result = vim_isIDc(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_SIDENT: /* \I */
+ case NFA_SIDENT: // \I
result = !VIM_ISDIGIT(curc) && vim_isIDc(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_KWORD: /* \k */
+ case NFA_KWORD: // \k
result = vim_iswordp_buf(rex.input, rex.reg_buf);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_SKWORD: /* \K */
+ case NFA_SKWORD: // \K
result = !VIM_ISDIGIT(curc)
&& vim_iswordp_buf(rex.input, rex.reg_buf);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_FNAME: /* \f */
+ case NFA_FNAME: // \f
result = vim_isfilec(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_SFNAME: /* \F */
+ case NFA_SFNAME: // \F
result = !VIM_ISDIGIT(curc) && vim_isfilec(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_PRINT: /* \p */
+ case NFA_PRINT: // \p
result = vim_isprintc(PTR2CHAR(rex.input));
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_SPRINT: /* \P */
+ case NFA_SPRINT: // \P
result = !VIM_ISDIGIT(curc) && vim_isprintc(PTR2CHAR(rex.input));
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_WHITE: /* \s */
+ case NFA_WHITE: // \s
result = VIM_ISWHITE(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NWHITE: /* \S */
+ case NFA_NWHITE: // \S
result = curc != NUL && !VIM_ISWHITE(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_DIGIT: /* \d */
+ case NFA_DIGIT: // \d
result = ri_digit(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NDIGIT: /* \D */
+ case NFA_NDIGIT: // \D
result = curc != NUL && !ri_digit(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_HEX: /* \x */
+ case NFA_HEX: // \x
result = ri_hex(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NHEX: /* \X */
+ case NFA_NHEX: // \X
result = curc != NUL && !ri_hex(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_OCTAL: /* \o */
+ case NFA_OCTAL: // \o
result = ri_octal(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NOCTAL: /* \O */
+ case NFA_NOCTAL: // \O
result = curc != NUL && !ri_octal(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_WORD: /* \w */
+ case NFA_WORD: // \w
result = ri_word(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NWORD: /* \W */
+ case NFA_NWORD: // \W
result = curc != NUL && !ri_word(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_HEAD: /* \h */
+ case NFA_HEAD: // \h
result = ri_head(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NHEAD: /* \H */
+ case NFA_NHEAD: // \H
result = curc != NUL && !ri_head(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_ALPHA: /* \a */
+ case NFA_ALPHA: // \a
result = ri_alpha(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NALPHA: /* \A */
+ case NFA_NALPHA: // \A
result = curc != NUL && !ri_alpha(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_LOWER: /* \l */
+ case NFA_LOWER: // \l
result = ri_lower(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NLOWER: /* \L */
+ case NFA_NLOWER: // \L
result = curc != NUL && !ri_lower(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_UPPER: /* \u */
+ case NFA_UPPER: // \u
result = ri_upper(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NUPPER: /* \U */
+ case NFA_NUPPER: // \U
result = curc != NUL && !ri_upper(curc);
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_LOWER_IC: /* [a-z] */
+ case NFA_LOWER_IC: // [a-z]
result = ri_lower(curc) || (rex.reg_ic && ri_upper(curc));
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NLOWER_IC: /* [^a-z] */
+ case NFA_NLOWER_IC: // [^a-z]
result = curc != NUL
&& !(ri_lower(curc) || (rex.reg_ic && ri_upper(curc)));
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_UPPER_IC: /* [A-Z] */
+ case NFA_UPPER_IC: // [A-Z]
result = ri_upper(curc) || (rex.reg_ic && ri_lower(curc));
ADD_STATE_IF_MATCH(t->state);
break;
- case NFA_NUPPER_IC: /* ^[A-Z] */
+ case NFA_NUPPER_IC: // ^[A-Z]
result = curc != NUL
&& !(ri_upper(curc) || (rex.reg_ic && ri_lower(curc)));
ADD_STATE_IF_MATCH(t->state);
case NFA_ZREF8:
case NFA_ZREF9:
#endif
- /* \1 .. \9 \z1 .. \z9 */
+ // \1 .. \9 \z1 .. \z9
{
int subidx;
int bytelen;
{
if (bytelen == 0)
{
- /* empty match always works, output of NFA_SKIP to be
- * used next */
+ // empty match always works, output of NFA_SKIP to be
+ // used next
add_here = TRUE;
add_state = t->state->out->out;
}
else if (bytelen <= clen)
{
- /* match current character, jump ahead to out of
- * NFA_SKIP */
+ // match current character, jump ahead to out of
+ // NFA_SKIP
add_state = t->state->out->out;
add_off = clen;
}
else
{
- /* skip over the matched characters, set character
- * count in NFA_SKIP */
+ // skip over the matched characters, set character
+ // count in NFA_SKIP
add_state = t->state->out;
add_off = bytelen;
add_count = bytelen - clen;
break;
}
case NFA_SKIP:
- /* character of previous matching \1 .. \9 or \@> */
+ // character of previous matching \1 .. \9 or \@>
if (t->count - clen <= 0)
{
- /* end of match, go to what follows */
+ // end of match, go to what follows
add_state = t->state->out;
add_off = clen;
}
else
{
- /* add state again with decremented count */
+ // add state again with decremented count
add_state = t->state;
add_off = 0;
add_count = t->count - clen;
colnr_T col = (colnr_T)(rex.input - rex.line);
win_T *wp = rex.reg_win == NULL ? curwin : rex.reg_win;
- /* Bail out quickly when there can't be a match, avoid the
- * overhead of win_linetabsize() on long lines. */
+ // Bail out quickly when there can't be a match, avoid the
+ // overhead of win_linetabsize() on long lines.
if (op != 1 && col > t->state->val
* (has_mbyte ? MB_MAXBYTES : 1))
break;
{
int ts = wp->w_buffer->b_p_ts;
- /* Guess that a character won't use more columns than
- * 'tabstop', with a minimum of 4. */
+ // Guess that a character won't use more columns than
+ // 'tabstop', with a minimum of 4.
if (ts < 4)
ts = 4;
result = col > t->state->val * ts;
{
pos_T *pos = getmark_buf(rex.reg_buf, t->state->val, FALSE);
- /* Compare the mark position to the match position. */
- result = (pos != NULL /* mark doesn't exist */
- && pos->lnum > 0 /* mark isn't set in reg_buf */
+ // Compare the mark position to the match position.
+ result = (pos != NULL // mark doesn't exist
+ && pos->lnum > 0 // mark isn't set in reg_buf
&& (pos->lnum == rex.lnum + rex.reg_firstlnum
? (pos->col == (colnr_T)(rex.input - rex.line)
? t->state->c == NFA_MARK
#endif
case NFA_NOPEN:
case NFA_ZSTART:
- /* These states are only added to be able to bail out when
- * they are added again, nothing is to be done. */
+ // These states are only added to be able to bail out when
+ // they are added again, nothing is to be done.
break;
- default: /* regular character */
+ default: // regular character
{
int c = t->state->c;
if (!result && rex.reg_ic)
result = MB_TOLOWER(c) == MB_TOLOWER(curc);
- /* If rex.reg_icombine is not set only skip over the character
- * itself. When it is set skip over composing characters. */
+ // If rex.reg_icombine is not set only skip over the character
+ // itself. When it is set skip over composing characters.
if (result && enc_utf8 && !rex.reg_icombine)
clen = utf_ptr2len(rex.input);
ADD_STATE_IF_MATCH(t->state);
break;
}
- } /* switch (t->state->c) */
+ } // switch (t->state->c)
if (add_state != NULL)
{
else
pim = &t->pim;
- /* Handle the postponed invisible match if the match might end
- * without advancing and before the end of the line. */
+ // Handle the postponed invisible match if the match might end
+ // without advancing and before the end of the line.
if (pim != NULL && (clen == 0 || match_follows(add_state, 0)))
{
if (pim->result == NFA_PIM_TODO)
result = recursive_regmatch(pim->state, pim,
prog, submatch, m, &listids, &listids_len);
pim->result = result ? NFA_PIM_MATCH : NFA_PIM_NOMATCH;
- /* for \@! and \@<! it is a match when the result is
- * FALSE */
+ // for \@! and \@<! it is a match when the result is
+ // FALSE
if (result != (pim->state->c == NFA_START_INVISIBLE_NEG
|| pim->state->c == NFA_START_INVISIBLE_NEG_FIRST
|| pim->state->c
|| pim->state->c
== NFA_START_INVISIBLE_BEFORE_NEG_FIRST))
{
- /* Copy submatch info from the recursive call */
+ // Copy submatch info from the recursive call
copy_sub_off(&pim->subs.norm, &m->norm);
#ifdef FEAT_SYN_HL
if (rex.nfa_has_zsubexpr)
#endif
}
- /* for \@! and \@<! it is a match when result is FALSE */
+ // for \@! and \@<! it is a match when result is FALSE
if (result != (pim->state->c == NFA_START_INVISIBLE_NEG
|| pim->state->c == NFA_START_INVISIBLE_NEG_FIRST
|| pim->state->c
|| pim->state->c
== NFA_START_INVISIBLE_BEFORE_NEG_FIRST))
{
- /* Copy submatch info from the recursive call */
+ // Copy submatch info from the recursive call
copy_sub_off(&t->subs.norm, &pim->subs.norm);
#ifdef FEAT_SYN_HL
if (rex.nfa_has_zsubexpr)
#endif
}
else
- /* look-behind match failed, don't add the state */
+ // look-behind match failed, don't add the state
continue;
- /* Postponed invisible match was handled, don't add it to
- * following states. */
+ // Postponed invisible match was handled, don't add it to
+ // following states.
pim = NULL;
}
- /* If "pim" points into l->t it will become invalid when
- * adding the state causes the list to be reallocated. Make a
- * local copy to avoid that. */
+ // If "pim" points into l->t it will become invalid when
+ // adding the state causes the list to be reallocated. Make a
+ // local copy to avoid that.
if (pim == &t->pim)
{
copy_pim(&pim_copy, pim);
}
}
- } /* for (thislist = thislist; thislist->state; thislist++) */
+ } // for (thislist = thislist; thislist->state; thislist++)
- /* Look for the start of a match in the current position by adding the
- * start state to the list of states.
- * The first found match is the leftmost one, thus the order of states
- * matters!
- * Do not add the start state in recursive calls of nfa_regmatch(),
- * because recursive calls should only start in the first position.
- * Unless "nfa_endp" is not NULL, then we match the end position.
- * Also don't start a match past the first line. */
+ // Look for the start of a match in the current position by adding the
+ // start state to the list of states.
+ // The first found match is the leftmost one, thus the order of states
+ // matters!
+ // Do not add the start state in recursive calls of nfa_regmatch(),
+ // because recursive calls should only start in the first position.
+ // Unless "nfa_endp" is not NULL, then we match the end position.
+ // Also don't start a match past the first line.
if (nfa_match == FALSE
&& ((toplevel
&& rex.lnum == 0
#ifdef ENABLE_LOG
fprintf(log_fd, "(---) STARTSTATE\n");
#endif
- /* Inline optimized code for addstate() if we know the state is
- * the first MOPEN. */
+ // Inline optimized code for addstate() if we know the state is
+ // the first MOPEN.
if (toplevel)
{
int add = TRUE;
{
colnr_T col = (colnr_T)(rex.input - rex.line) + clen;
- /* Nextlist is empty, we can skip ahead to the
- * character that must appear at the start. */
+ // Nextlist is empty, we can skip ahead to the
+ // character that must appear at the start.
if (skip_to_start(prog->regstart, &col) == FAIL)
break;
#ifdef ENABLE_LOG
}
else
{
- /* Checking if the required start character matches is
- * cheaper than adding a state that won't match. */
+ // Checking if the required start character matches is
+ // cheaper than adding a state that won't match.
c = PTR2CHAR(rex.input + clen);
if (c != prog->regstart && (!rex.reg_ic
|| MB_TOLOWER(c) != MB_TOLOWER(prog->regstart)))
#endif
nextchar:
- /* Advance to the next character, or advance to the next line, or
- * finish. */
+ // Advance to the next character, or advance to the next line, or
+ // finish.
if (clen != 0)
rex.input += clen;
else if (go_to_nextline || (nfa_endp != NULL && REG_MULTI
else
break;
- /* Allow interrupting with CTRL-C. */
+ // Allow interrupting with CTRL-C.
line_breakcheck();
if (got_int)
break;
#ifdef FEAT_RELTIME
- /* Check for timeout once in a twenty times to avoid overhead. */
+ // Check for timeout once in a twenty times to avoid overhead.
if (nfa_time_limit != NULL && ++nfa_time_count == 20)
{
nfa_time_count = 0;
#endif
theend:
- /* Free memory */
+ // Free memory
vim_free(list[0].t);
vim_free(list[1].t);
vim_free(listids);
nfa_regtry(
nfa_regprog_T *prog,
colnr_T col,
- proftime_T *tm UNUSED, /* timeout limit or NULL */
- int *timed_out UNUSED) /* flag set on timeout or NULL */
+ proftime_T *tm UNUSED, // timeout limit or NULL
+ int *timed_out UNUSED) // flag set on timeout or NULL
{
int i;
regsubs_T subs, m;
}
if (rex.reg_endpos[0].lnum < 0)
{
- /* pattern has a \ze but it didn't match, use current end */
+ // pattern has a \ze but it didn't match, use current end
rex.reg_endpos[0].lnum = rex.lnum;
rex.reg_endpos[0].col = (int)(rex.input - rex.line);
}
else
- /* Use line number of "\ze". */
+ // Use line number of "\ze".
rex.lnum = rex.reg_endpos[0].lnum;
}
else
}
#ifdef FEAT_SYN_HL
- /* Package any found \z(...\) matches for export. Default is none. */
+ // Package any found \z(...\) matches for export. Default is none.
unref_extmatch(re_extmatch_out);
re_extmatch_out = NULL;
{
cleanup_zsubexpr();
re_extmatch_out = make_extmatch();
- /* Loop over \z1, \z2, etc. There is no \z0. */
+ // Loop over \z1, \z2, etc. There is no \z0.
for (i = 1; i < subs.synt.in_use; i++)
{
if (REG_MULTI)
{
struct multipos *mpos = &subs.synt.list.multi[i];
- /* Only accept single line matches that are valid. */
+ // Only accept single line matches that are valid.
if (mpos->start_lnum >= 0
&& mpos->start_lnum == mpos->end_lnum
&& mpos->end_col >= mpos->start_col)
static long
nfa_regexec_both(
char_u *line,
- colnr_T startcol, /* column to start looking for match */
- proftime_T *tm, /* timeout limit or NULL */
- int *timed_out) /* flag set on timeout or NULL */
+ colnr_T startcol, // column to start looking for match
+ proftime_T *tm, // timeout limit or NULL
+ int *timed_out) // flag set on timeout or NULL
{
nfa_regprog_T *prog;
long retval = 0L;
if (REG_MULTI)
{
prog = (nfa_regprog_T *)rex.reg_mmatch->regprog;
- line = reg_getline((linenr_T)0); /* relative to the cursor */
+ line = reg_getline((linenr_T)0); // relative to the cursor
rex.reg_startpos = rex.reg_mmatch->startpos;
rex.reg_endpos = rex.reg_mmatch->endpos;
}
rex.reg_endp = rex.reg_match->endp;
}
- /* Be paranoid... */
+ // Be paranoid...
if (prog == NULL || line == NULL)
{
emsg(_(e_null));
goto theend;
}
- /* If pattern contains "\c" or "\C": overrule value of rex.reg_ic */
+ // If pattern contains "\c" or "\C": overrule value of rex.reg_ic
if (prog->regflags & RF_ICASE)
rex.reg_ic = TRUE;
else if (prog->regflags & RF_NOICASE)
rex.reg_ic = FALSE;
- /* If pattern contains "\Z" overrule value of rex.reg_icombine */
+ // If pattern contains "\Z" overrule value of rex.reg_icombine
if (prog->regflags & RF_ICOMBINE)
rex.reg_icombine = TRUE;
rex.line = line;
- rex.lnum = 0; /* relative to line */
+ rex.lnum = 0; // relative to line
rex.nfa_has_zend = prog->has_zend;
rex.nfa_has_backref = prog->has_backref;
rex.need_clear_subexpr = TRUE;
#ifdef FEAT_SYN_HL
- /* Clear the external match subpointers if necessary. */
+ // Clear the external match subpointers if necessary.
if (prog->reghasz == REX_SET)
{
rex.nfa_has_zsubexpr = TRUE;
if (prog->regstart != NUL)
{
- /* Skip ahead until a character we know the match must start with.
- * When there is none there is no match. */
+ // Skip ahead until a character we know the match must start with.
+ // When there is none there is no match.
if (skip_to_start(prog->regstart, &col) == FAIL)
return 0L;
- /* If match_text is set it contains the full text that must match.
- * Nothing else to try. Doesn't handle combining chars well. */
+ // If match_text is set it contains the full text that must match.
+ // Nothing else to try. Doesn't handle combining chars well.
if (prog->match_text != NULL && !rex.reg_icombine)
return find_match_text(col, prog->regstart, prog->match_text);
}
- /* If the start column is past the maximum column: no need to try. */
+ // If the start column is past the maximum column: no need to try.
if (rex.reg_maxcol > 0 && col >= rex.reg_maxcol)
goto theend;
if (nfa_regcomp_start(expr, re_flags) == FAIL)
return NULL;
- /* Build postfix form of the regexp. Needed to build the NFA
- * (and count its size). */
+ // Build postfix form of the regexp. Needed to build the NFA
+ // (and count its size).
postfix = re2post();
if (postfix == NULL)
- goto fail; /* Cascaded (syntax?) error */
+ goto fail; // Cascaded (syntax?) error
/*
* In order to build the NFA, we parse the input regexp twice:
*/
post2nfa(postfix, post_ptr, TRUE);
- /* allocate the regprog with space for the compiled regexp */
+ // allocate the regprog with space for the compiled regexp
prog_size = sizeof(nfa_regprog_T) + sizeof(nfa_state_T) * (nstate - 1);
prog = alloc(prog_size);
if (prog == NULL)
nfa_dump(prog);
#endif
#ifdef FEAT_SYN_HL
- /* Remember whether this pattern has any \z specials in it. */
+ // Remember whether this pattern has any \z specials in it.
prog->reghasz = re_has_z;
#endif
prog->pattern = vim_strsave(expr);
static int
nfa_regexec_nl(
regmatch_T *rmp,
- char_u *line, /* string to match against */
- colnr_T col, /* column to start looking for match */
+ char_u *line, // string to match against
+ colnr_T col, // column to start looking for match
int line_lbr)
{
rex.reg_match = rmp;
static long
nfa_regexec_multi(
regmmatch_T *rmp,
- win_T *win, /* window in which to search or NULL */
- buf_T *buf, /* buffer in which to search */
- linenr_T lnum, /* nr of line to start looking for match */
- colnr_T col, /* column to start looking for match */
- proftime_T *tm, /* timeout limit or NULL */
- int *timed_out) /* flag set on timeout or NULL */
+ win_T *win, // window in which to search or NULL
+ buf_T *buf, // buffer in which to search
+ linenr_T lnum, // nr of line to start looking for match
+ colnr_T col, // column to start looking for match
+ proftime_T *tm, // timeout limit or NULL
+ int *timed_out) // flag set on timeout or NULL
{
rex.reg_match = NULL;
rex.reg_mmatch = rmp;
static void msg_pos_mode(void);
static void recording_mode(int attr);
-/* Ugly global: overrule attribute used by screen_char() */
+// Ugly global: overrule attribute used by screen_char()
static int screen_char_attr = 0;
#if defined(FEAT_CONCEAL) || defined(PROTO)
if (curwin->w_p_cole > 0 && conceal_cursor_line(curwin))
{
need_cursor_line_redraw = TRUE;
- /* Need to recompute cursor column, e.g., when starting Visual mode
- * without concealing. */
+ // Need to recompute cursor column, e.g., when starting Visual mode
+ // without concealing.
curs_columns(TRUE);
}
}
fill_foldcolumn(
char_u *p,
win_T *wp,
- int closed, /* TRUE of FALSE */
- linenr_T lnum) /* current line number */
+ int closed, // TRUE of FALSE
+ linenr_T lnum) // current line number
{
int i = 0;
int level;
int empty;
int fdc = compute_foldcolumn(wp, 0);
- /* Init to all spaces. */
+ // Init to all spaces.
vim_memset(p, ' ', (size_t)fdc);
level = win_foldinfo.fi_level;
if (level > 0)
{
- /* If there is only one column put more info in it. */
+ // If there is only one column put more info in it.
empty = (fdc == 1) ? 0 : 1;
- /* If the column is too narrow, we start at the lowest level that
- * fits and use numbers to indicated the depth. */
+ // If the column is too narrow, we start at the lowest level that
+ // fits and use numbers to indicated the depth.
first_level = level - fdc - closed + 1 + empty;
if (first_level < 1)
first_level = 1;
if (closed)
p[i >= fdc ? i - 1 : i] = '+';
}
-#endif /* FEAT_FOLDING */
+#endif // FEAT_FOLDING
/*
* Return if the composing characters at "off_from" and "off_to" differ.
unsigned max_off_to;
int col = 0;
int hl;
- int force = FALSE; /* force update rest of the line */
- int redraw_this /* bool: does character need redraw? */
+ int force = FALSE; // force update rest of the line
+ int redraw_this // bool: does character need redraw?
#ifdef FEAT_GUI
- = TRUE /* For GUI when while-loop empty */
+ = TRUE // For GUI when while-loop empty
#endif
;
- int redraw_next; /* redraw_this for next character */
+ int redraw_next; // redraw_this for next character
int clear_next = FALSE;
- int char_cells; /* 1: normal char */
- /* 2: occupies two display cells */
+ int char_cells; // 1: normal char
+ // 2: occupies two display cells
# define CHAR_CELLS char_cells
- /* Check for illegal row and col, just in case. */
+ // Check for illegal row and col, just in case.
if (row >= Rows)
row = Rows - 1;
if (endcol > Columns)
#ifdef FEAT_RIGHTLEFT
if (flags & SLF_RIGHTLEFT)
{
- /* Clear rest first, because it's left of the text. */
+ // Clear rest first, because it's left of the text.
if (clear_width > 0)
{
while (col <= endcol && ScreenLines[off_to] == ' '
off_from += col;
endcol = (clear_width > 0 ? clear_width : -clear_width);
}
-#endif /* FEAT_RIGHTLEFT */
+#endif // FEAT_RIGHTLEFT
#ifdef FEAT_PROP_POPUP
// First char of a popup window may go on top of the right half of a
off_to + CHAR_CELLS, endcol - col - CHAR_CELLS);
#ifdef FEAT_GUI
- /* If the next character was bold, then redraw the current character to
- * remove any pixels that might have spilt over into us. This only
- * happens in the GUI.
- */
+ // If the next character was bold, then redraw the current character to
+ // remove any pixels that might have spilt over into us. This only
+ // happens in the GUI.
if (redraw_next && gui.in_use)
{
hl = ScreenAttrs[off_to + CHAR_CELLS];
* Need to remove highlighting attributes here.
*/
windgoto(row, col + coloff);
- out_str(T_CE); /* clear rest of this screen line */
- screen_start(); /* don't know where cursor is now */
- force = TRUE; /* force redraw of rest of the line */
- redraw_next = TRUE; /* or else next char would miss out */
+ out_str(T_CE); // clear rest of this screen line
+ screen_start(); // don't know where cursor is now
+ force = TRUE; // force redraw of rest of the line
+ redraw_next = TRUE; // or else next char would miss out
/*
* If the previous character was highlighted, need to stop
screen_stop_highlight();
}
else
- screen_attr = 0; /* highlighting has stopped */
+ screen_attr = 0; // highlighting has stopped
}
if (enc_dbcs != 0)
{
- /* Check if overwriting a double-byte with a single-byte or
- * the other way around requires another character to be
- * redrawn. For UTF-8 this isn't needed, because comparing
- * ScreenLinesUC[] is sufficient. */
+ // Check if overwriting a double-byte with a single-byte or
+ // the other way around requires another character to be
+ // redrawn. For UTF-8 this isn't needed, because comparing
+ // ScreenLinesUC[] is sufficient.
if (char_cells == 1
&& col + 1 < endcol
&& (*mb_off2cells)(off_to, max_off_to) > 1)
{
- /* Writing a single-cell character over a double-cell
- * character: need to redraw the next cell. */
+ // Writing a single-cell character over a double-cell
+ // character: need to redraw the next cell.
ScreenLines[off_to + 1] = 0;
redraw_next = TRUE;
}
&& (*mb_off2cells)(off_to, max_off_to) == 1
&& (*mb_off2cells)(off_to + 1, max_off_to) > 1)
{
- /* Writing the second half of a double-cell character over
- * a double-cell character: need to redraw the second
- * cell. */
+ // Writing the second half of a double-cell character over
+ // a double-cell character: need to redraw the second
+ // cell.
ScreenLines[off_to + 2] = 0;
redraw_next = TRUE;
}
if (enc_dbcs == DBCS_JPNU)
ScreenLines2[off_to] = ScreenLines2[off_from];
}
- /* When writing a single-width character over a double-width
- * character and at the end of the redrawn text, need to clear out
- * the right halve of the old character.
- * Also required when writing the right halve of a double-width
- * char over the left halve of an existing one. */
+ // When writing a single-width character over a double-width
+ // character and at the end of the redrawn text, need to clear out
+ // the right halve of the old character.
+ // Also required when writing the right halve of a double-width
+ // char over the left halve of an existing one.
if (has_mbyte && col + char_cells == endcol
&& ((char_cells == 1
&& (*mb_off2cells)(off_to, max_off_to) > 1)
ScreenLines[off_to + 1] = ScreenLines[off_from + 1];
#if defined(FEAT_GUI) || defined(UNIX)
- /* The bold trick makes a single column of pixels appear in the
- * next character. When a bold character is removed, the next
- * character should be redrawn too. This happens for our own GUI
- * and for some xterms. */
+ // The bold trick makes a single column of pixels appear in the
+ // next character. When a bold character is removed, the next
+ // character should be redrawn too. This happens for our own GUI
+ // and for some xterms.
if (
# ifdef FEAT_GUI
gui.in_use
#endif
ScreenAttrs[off_to] = ScreenAttrs[off_from];
- /* For simplicity set the attributes of second half of a
- * double-wide character equal to the first half. */
+ // For simplicity set the attributes of second half of a
+ // double-wide character equal to the first half.
if (char_cells == 2)
ScreenAttrs[off_to + 1] = ScreenAttrs[off_from];
if (clear_next)
{
- /* Clear the second half of a double-wide character of which the left
- * half was overwritten with a single-wide character. */
+ // Clear the second half of a double-wide character of which the left
+ // half was overwritten with a single-wide character.
ScreenLines[off_to] = ' ';
if (enc_utf8)
ScreenLinesUC[off_to] = 0;
int startCol = col;
#endif
- /* blank out the rest of the line */
+ // blank out the rest of the line
while (col < clear_width && ScreenLines[off_to] == ' '
&& ScreenAttrs[off_to] == 0
&& (!enc_utf8 || ScreenLinesUC[off_to] == 0))
int prev_cells = 1;
if (enc_utf8)
- /* for utf-8, ScreenLines[char_offset + 1] == 0 means
- * that its width is 2. */
+ // for utf-8, ScreenLines[char_offset + 1] == 0 means
+ // that its width is 2.
prev_cells = ScreenLines[off_to - 1] == 0 ? 2 : 1;
else if (enc_dbcs != 0)
{
- /* find previous character by counting from first
- * column and get its width. */
+ // find previous character by counting from first
+ // column and get its width.
unsigned off = LineOffset[row];
unsigned max_off = LineOffset[row] + screen_Columns;
if (wp->w_vsep_width)
{
- /* draw the vertical separator right of this window */
+ // draw the vertical separator right of this window
c = fillchar_vsep(&hl);
screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height,
W_ENDCOL(wp), W_ENDCOL(wp) + 1,
int emenu = (xp->xp_context == EXPAND_MENUS
|| xp->xp_context == EXPAND_MENUNAMES);
- /* Check for menu separators - replace with '|'. */
+ // Check for menu separators - replace with '|'.
if (emenu && menu_is_separator(s))
return 1;
#endif
win_redr_status_matches(
expand_T *xp,
int num_matches,
- char_u **matches, /* list of matches */
+ char_u **matches, // list of matches
int match,
int showtail)
{
int row;
char_u *buf;
int len;
- int clen; /* length in screen cells */
+ int clen; // length in screen cells
int fillchar;
int attr;
int i;
#endif
int l;
- if (matches == NULL) /* interrupted completion? */
+ if (matches == NULL) // interrupted completion?
return;
if (has_mbyte)
if (buf == NULL)
return;
- if (match == -1) /* don't show match but original text */
+ if (match == -1) // don't show match but original text
{
match = 0;
highlight = FALSE;
}
- /* count 1 for the ending ">" */
+ // count 1 for the ending ">"
clen = status_match_len(xp, L_MATCH(match)) + 3;
if (match == 0)
first_match = 0;
else if (match < first_match)
{
- /* jumping left, as far as we can go */
+ // jumping left, as far as we can go
first_match = match;
add_left = TRUE;
}
else
{
- /* check if match fits on the screen */
+ // check if match fits on the screen
for (i = first_match; i < match; ++i)
clen += status_match_len(xp, L_MATCH(i)) + 2;
if (first_match > 0)
clen += 2;
- /* jumping right, put match at the left */
+ // jumping right, put match at the left
if ((long)clen > Columns)
{
first_match = match;
- /* if showing the last match, we can add some on the left */
+ // if showing the last match, we can add some on the left
clen = 2;
for (i = match; i < num_matches; ++i)
{
}
s = L_MATCH(i);
- /* Check for menu separators - replace with '|' */
+ // Check for menu separators - replace with '|'
#ifdef FEAT_MENU
emenu = (xp->xp_context == EXPAND_MENUS
|| xp->xp_context == EXPAND_MENUNAMES);
{
if (msg_scrolled > 0)
{
- /* Put the wildmenu just above the command line. If there is
- * no room, scroll the screen one line up. */
+ // Put the wildmenu just above the command line. If there is
+ // no room, scroll the screen one line up.
if (cmdline_row == Rows - 1)
{
screen_del_lines(0, 0, 1, (int)Rows, TRUE, 0, NULL);
}
else
{
- /* Create status line if needed by setting 'laststatus' to 2.
- * Set 'winminheight' to zero to avoid that the window is
- * resized. */
+ // Create status line if needed by setting 'laststatus' to 2.
+ // Set 'winminheight' to zero to avoid that the window is
+ // resized.
if (lastwin->w_status_height == 0)
{
save_p_ls = p_ls;
int
get_keymap_str(
win_T *wp,
- char_u *fmt, /* format string containing one %s item */
- char_u *buf, /* buffer for the result */
- int len) /* length of buffer */
+ char_u *fmt, // format string containing one %s item
+ char_u *buf, // buffer for the result
+ int len) // length of buffer
{
char_u *p;
curbuf = wp->w_buffer;
curwin = wp;
- STRCPY(buf, "b:keymap_name"); /* must be writable */
+ STRCPY(buf, "b:keymap_name"); // must be writable
++emsg_skip;
s = p = eval_to_string(buf, NULL, FALSE);
--emsg_skip;
&& *ptr != NUL)
{
c = *ptr;
- /* check if this is the first byte of a multibyte */
+ // check if this is the first byte of a multibyte
if (has_mbyte)
{
if (enc_utf8 && len > 0)
mbyte_cells = 1;
else if (enc_dbcs != 0)
mbyte_cells = mbyte_blen;
- else /* enc_utf8 */
+ else // enc_utf8
{
if (len >= 0)
u8c = utfc_ptr2char_len(ptr, u8cc,
#ifdef FEAT_ARABIC
if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c))
{
- /* Do Arabic shaping. */
+ // Do Arabic shaping.
if (len >= 0 && (int)(ptr - text) + mbyte_blen >= len)
{
- /* Past end of string to be displayed. */
+ // Past end of string to be displayed.
nc = NUL;
nc1 = NUL;
}
#endif
if (col + mbyte_cells > screen_Columns)
{
- /* Only 1 cell left, but character requires 2 cells:
- * display a '>' in the last column to avoid wrapping. */
+ // Only 1 cell left, but character requires 2 cells:
+ // display a '>' in the last column to avoid wrapping.
c = '>';
mbyte_cells = 1;
}
)
{
#if defined(FEAT_GUI) || defined(UNIX)
- /* The bold trick makes a single row of pixels appear in the next
- * character. When a bold character is removed, the next
- * character should be redrawn too. This happens for our own GUI
- * and for some xterms. */
+ // The bold trick makes a single row of pixels appear in the next
+ // character. When a bold character is removed, the next
+ // character should be redrawn too. This happens for our own GUI
+ // and for some xterms.
if (need_redraw && ScreenLines[off] != ' ' && (
# ifdef FEAT_GUI
gui.in_use
force_redraw_next = TRUE;
}
#endif
- /* When at the end of the text and overwriting a two-cell
- * character with a one-cell character, need to clear the next
- * cell. Also when overwriting the left halve of a two-cell char
- * with the right halve of a two-cell char. Do this only once
- * (mb_off2cells() may return 2 on the right halve). */
+ // When at the end of the text and overwriting a two-cell
+ // character with a one-cell character, need to clear the next
+ // cell. Also when overwriting the left halve of a two-cell char
+ // with the right halve of a two-cell char. Do this only once
+ // (mb_off2cells() may return 2 on the right halve).
if (clear_next_cell)
clear_next_cell = FALSE;
else if (has_mbyte
&& (*mb_off2cells)(off + 1, max_off) > 1)))
clear_next_cell = TRUE;
- /* Make sure we never leave a second byte of a double-byte behind,
- * it confuses mb_off2cells(). */
+ // Make sure we never leave a second byte of a double-byte behind,
+ // it confuses mb_off2cells().
if (enc_dbcs
&& ((mbyte_cells == 1 && (*mb_off2cells)(off, max_off) > 1)
|| (mbyte_cells == 2
ptr += mbyte_blen;
if (clear_next_cell)
{
- /* This only happens at the end, display one space next. */
+ // This only happens at the end, display one space next.
ptr = (char_u *)" ";
len = -1;
}
}
}
- /* If we detected the next character needs to be redrawn, but the text
- * doesn't extend up to there, update the character here. */
+ // If we detected the next character needs to be redrawn, but the text
+ // doesn't extend up to there, update the character here.
if (force_redraw_next && col < screen_Columns)
{
if (enc_dbcs != 0 && dbcs_off2cells(off, max_off) > 1)
last_pat_prog(&screen_search_hl.rm);
screen_search_hl.attr = HL_ATTR(HLF_L);
# ifdef FEAT_RELTIME
- /* Set the time limit to 'redrawtime'. */
+ // Set the time limit to 'redrawtime'.
profile_setlimit(p_rdt, &screen_search_hl.tm);
# endif
}
{
char buf[20];
- /* The GUI handles this internally. */
+ // The GUI handles this internally.
sprintf(buf, IF_EB("\033|%dh", ESC_STR "|%dh"), attr);
OUT_STR(buf);
}
else
#endif
{
- if (attr > HL_ALL) /* special HL attr. */
+ if (attr > HL_ALL) // special HL attr.
{
if (IS_CTERM)
aep = syn_cterm_attr2entry(attr);
else
aep = syn_term_attr2entry(attr);
- if (aep == NULL) /* did ":syntax clear" */
+ if (aep == NULL) // did ":syntax clear"
attr = 0;
else
attr = aep->ae_attr;
}
}
#endif
- if ((attr & HL_BOLD) && *T_MD != NUL) /* bold */
+ if ((attr & HL_BOLD) && *T_MD != NUL) // bold
out_str(T_MD);
else if (aep != NULL && cterm_normal_fg_bold && (
#ifdef FEAT_TERMGUICOLORS
:
#endif
t_colors > 1 && aep->ae_u.cterm.fg_color))
- /* If the Normal FG color has BOLD attribute and the new HL
- * has a FG color defined, clear BOLD. */
+ // If the Normal FG color has BOLD attribute and the new HL
+ // has a FG color defined, clear BOLD.
out_str(T_ME);
- if ((attr & HL_STANDOUT) && *T_SO != NUL) /* standout */
+ if ((attr & HL_STANDOUT) && *T_SO != NUL) // standout
out_str(T_SO);
- if ((attr & HL_UNDERCURL) && *T_UCS != NUL) /* undercurl */
+ if ((attr & HL_UNDERCURL) && *T_UCS != NUL) // undercurl
out_str(T_UCS);
- if (((attr & HL_UNDERLINE) /* underline or undercurl */
+ if (((attr & HL_UNDERLINE) // underline or undercurl
|| ((attr & HL_UNDERCURL) && *T_UCS == NUL))
&& *T_US != NUL)
out_str(T_US);
- if ((attr & HL_ITALIC) && *T_CZH != NUL) /* italic */
+ if ((attr & HL_ITALIC) && *T_CZH != NUL) // italic
out_str(T_CZH);
- if ((attr & HL_INVERSE) && *T_MR != NUL) /* inverse (reverse) */
+ if ((attr & HL_INVERSE) && *T_MR != NUL) // inverse (reverse)
out_str(T_MR);
- if ((attr & HL_STRIKETHROUGH) && *T_STS != NUL) /* strike */
+ if ((attr & HL_STRIKETHROUGH) && *T_STS != NUL) // strike
out_str(T_STS);
/*
if (aep != NULL)
{
#ifdef FEAT_TERMGUICOLORS
- /* When 'termguicolors' is set but fg or bg is unset,
- * fall back to the cterm colors. This helps for SpellBad,
- * where the GUI uses a red undercurl. */
+ // When 'termguicolors' is set but fg or bg is unset,
+ // fall back to the cterm colors. This helps for SpellBad,
+ // where the GUI uses a red undercurl.
if (p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR)
{
if (aep->ae_u.cterm.fg_rgb != INVALCOLOR)
void
screen_stop_highlight(void)
{
- int do_ME = FALSE; /* output T_ME code */
+ int do_ME = FALSE; // output T_ME code
if (screen_attr != 0
#ifdef MSWIN
{
char buf[20];
- /* use internal GUI code */
+ // use internal GUI code
sprintf(buf, IF_EB("\033|%dH", ESC_STR "|%dH"), screen_attr);
OUT_STR(buf);
}
else
#endif
{
- if (screen_attr > HL_ALL) /* special HL attr. */
+ if (screen_attr > HL_ALL) // special HL attr.
{
attrentry_T *aep;
out_str(aep->ae_u.term.stop);
}
}
- if (aep == NULL) /* did ":syntax clear" */
+ if (aep == NULL) // did ":syntax clear"
screen_attr = 0;
else
screen_attr = aep->ae_attr;
{
if (t_colors > 1)
{
- /* set Normal cterm colors */
+ // set Normal cterm colors
if (cterm_normal_fg_color != 0)
term_fg_color(cterm_normal_fg_color - 1);
if (cterm_normal_bg_color != 0)
{
if (IS_CTERM)
{
- /* set Normal cterm colors */
+ // set Normal cterm colors
#ifdef FEAT_TERMGUICOLORS
if (p_tgc ? (cterm_normal_fg_gui_color != INVALCOLOR
|| cterm_normal_bg_gui_color != INVALCOLOR)
{
int attr;
- /* Check for illegal values, just in case (could happen just after
- * resizing). */
+ // Check for illegal values, just in case (could happen just after
+ // resizing).
if (row >= screen_Rows || col >= screen_Columns)
return;
return;
#endif
- /* Outputting a character in the last cell on the screen may scroll the
- * screen up. Only do it when the "xn" termcap property is set, otherwise
- * mark the character invalid (update it when scrolled up). */
+ // Outputting a character in the last cell on the screen may scroll the
+ // screen up. Only do it when the "xn" termcap property is set, otherwise
+ // mark the character invalid (update it when scrolled up).
if (*T_XN == NUL
&& row == screen_Rows - 1 && col == screen_Columns - 1
#ifdef FEAT_RIGHTLEFT
- /* account for first command-line character in rightleft mode */
+ // account for first command-line character in rightleft mode
&& !cmdmsg_rl
#endif
)
#endif
)
{
- /* Clear the two screen cells. If the character is actually
- * single width it won't change the second cell. */
+ // Clear the two screen cells. If the character is actually
+ // single width it won't change the second cell.
out_str((char_u *)" ");
term_windgoto(row, col);
}
- /* not sure where the cursor is after drawing the ambiguous width
- * character */
+ // not sure where the cursor is after drawing the ambiguous width
+ // character
screen_cur_col = 9999;
}
else if (utf_char2cells(ScreenLinesUC[off]) > 1)
++screen_cur_col;
- /* Convert the UTF-8 character to bytes and write it. */
+ // Convert the UTF-8 character to bytes and write it.
buf[utfc_char2bytes(off, buf)] = NUL;
out_str(buf);
}
{
out_flush_check();
out_char(ScreenLines[off]);
- /* double-byte character in single-width cell */
+ // double-byte character in single-width cell
if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
out_char(ScreenLines2[off]);
}
static void
screen_char_2(unsigned off, int row, int col)
{
- /* Check for illegal values (could be wrong when screen was resized). */
+ // Check for illegal values (could be wrong when screen was resized).
if (off + 1 >= (unsigned)(screen_Rows * screen_Columns))
return;
- /* Outputting the last character on the screen may scrollup the screen.
- * Don't to it! Mark the character invalid (update it when scrolled up) */
+ // Outputting the last character on the screen may scrollup the screen.
+ // Don't to it! Mark the character invalid (update it when scrolled up)
if (row == screen_Rows - 1 && col >= screen_Columns - 2)
{
ScreenAttrs[off] = (sattr_T)-1;
return;
}
- /* Output the first byte normally (positions the cursor), then write the
- * second byte directly. */
+ // Output the first byte normally (positions the cursor), then write the
+ // second byte directly.
screen_char(off, row, col);
out_char(ScreenLines[off + 1]);
++screen_cur_col;
int off;
int max_off;
- /* Can't use ScreenLines unless initialized */
+ // Can't use ScreenLines unless initialized
if (ScreenLines == NULL)
return;
int force_next = FALSE;
#endif
- if (end_row > screen_Rows) /* safety check */
+ if (end_row > screen_Rows) // safety check
end_row = screen_Rows;
- if (end_col > screen_Columns) /* safety check */
+ if (end_col > screen_Columns) // safety check
end_col = screen_Columns;
if (ScreenLines == NULL
|| start_row >= end_row
- || start_col >= end_col) /* nothing to do */
+ || start_col >= end_col) // nothing to do
return;
- /* it's a "normal" terminal when not in a GUI or cterm */
+ // it's a "normal" terminal when not in a GUI or cterm
norm_term = (
#ifdef FEAT_GUI
!gui.in_use &&
#endif
)
{
- /* When drawing over the right halve of a double-wide char clear
- * out the left halve. When drawing over the left halve of a
- * double wide-char clear out the right halve. Only needed in a
- * terminal. */
+ // When drawing over the right halve of a double-wide char clear
+ // out the left halve. When drawing over the left halve of a
+ // double wide-char clear out the right halve. Only needed in a
+ // terminal.
if (start_col > 0 && mb_fix_col(start_col, row) != start_col)
screen_puts_len((char_u *)" ", 1, row, start_col - 1, 0);
if (end_col < screen_Columns && mb_fix_col(end_col, row) != end_col)
* check if we really need to clear something
*/
col = start_col;
- if (c1 != ' ') /* don't clear first char */
+ if (c1 != ' ') // don't clear first char
++col;
off = LineOffset[row] + col;
end_off = LineOffset[row] + end_col;
- /* skip blanks (used often, keep it fast!) */
+ // skip blanks (used often, keep it fast!)
if (enc_utf8)
while (off < end_off && ScreenLines[off] == ' '
&& ScreenAttrs[off] == 0 && ScreenLinesUC[off] == 0)
while (off < end_off && ScreenLines[off] == ' '
&& ScreenAttrs[off] == 0)
++off;
- if (off < end_off) /* something to be cleared */
+ if (off < end_off) // something to be cleared
{
col = off - LineOffset[row];
screen_stop_highlight();
- term_windgoto(row, col);/* clear rest of this screen line */
+ term_windgoto(row, col);// clear rest of this screen line
out_str(T_CE);
- screen_start(); /* don't know where cursor is now */
+ screen_start(); // don't know where cursor is now
col = end_col - col;
- while (col--) /* clear chars in ScreenLines */
+ while (col--) // clear chars in ScreenLines
{
space_to_screenline(off, 0);
++off;
}
}
- did_delete = TRUE; /* the chars are cleared now */
+ did_delete = TRUE; // the chars are cleared now
}
off = LineOffset[row] + start_col;
)
{
#if defined(FEAT_GUI) || defined(UNIX)
- /* The bold trick may make a single row of pixels appear in
- * the next character. When a bold character is removed, the
- * next character should be redrawn too. This happens for our
- * own GUI and for some xterms. */
+ // The bold trick may make a single row of pixels appear in
+ // the next character. When a bold character is removed, the
+ // next character should be redrawn too. This happens for our
+ // own GUI and for some xterms.
if (
# ifdef FEAT_GUI
gui.in_use
}
if (end_col == Columns)
LineWraps[row] = FALSE;
- if (row == Rows - 1) /* overwritten the command line */
+ if (row == Rows - 1) // overwritten the command line
{
redraw_cmdline = TRUE;
if (start_col == 0 && end_col == Columns
&& c1 == ' ' && c2 == ' ' && attr == 0)
- clear_cmdline = FALSE; /* command line has been cleared */
+ clear_cmdline = FALSE; // command line has been cleared
if (start_col == 0)
- mode_displayed = FALSE; /* mode cleared or overwritten */
+ mode_displayed = FALSE; // mode cleared or overwritten
}
}
}
int
screen_valid(int doclear)
{
- screenalloc(doclear); /* allocate screen buffers if size changed */
+ screenalloc(doclear); // allocate screen buffers if size changed
return (ScreenLines != NULL);
}
char *new_popup_transparent;
#endif
tabpage_T *tp;
- static int entered = FALSE; /* avoid recursiveness */
- static int done_outofmem_msg = FALSE; /* did outofmem message */
+ static int entered = FALSE; // avoid recursiveness
+ static int done_outofmem_msg = FALSE; // did outofmem message
int retry_count = 0;
retry:
*/
++RedrawingDisabled;
- win_new_shellsize(); /* fit the windows in the new sized shell */
+ win_new_shellsize(); // fit the windows in the new sized shell
- comp_col(); /* recompute columns for shown command and ruler */
+ comp_col(); // recompute columns for shown command and ruler
/*
* We're changing the size of the screen.
{
if (ScreenLines != NULL || !done_outofmem_msg)
{
- /* guess the size */
+ // guess the size
do_outofmem_msg((long_u)((Rows + 1) * Columns));
- /* Remember we did this to avoid getting outofmem messages over
- * and over again. */
+ // Remember we did this to avoid getting outofmem messages over
+ // and over again.
done_outofmem_msg = TRUE;
}
VIM_CLEAR(new_ScreenLines);
len = screen_Columns;
else
len = Columns;
- /* When switching to utf-8 don't copy characters, they
- * may be invalid now. Also when p_mco changes. */
+ // When switching to utf-8 don't copy characters, they
+ // may be invalid now. Also when p_mco changes.
if (!(enc_utf8 && ScreenLinesUC == NULL)
&& p_mco == Screen_mco)
mch_memmove(new_ScreenLines + new_LineOffset[new_row],
}
}
}
- /* Use the last line of the screen for the current line. */
+ // Use the last line of the screen for the current line.
current_ScreenLine = new_ScreenLines + Rows * Columns;
#ifdef FEAT_PROP_POPUP
popup_mask_refresh = TRUE;
#endif
- /* It's important that screen_Rows and screen_Columns reflect the actual
- * size of ScreenLines[]. Set them before calling anything. */
+ // It's important that screen_Rows and screen_Columns reflect the actual
+ // size of ScreenLines[]. Set them before calling anything.
#ifdef FEAT_GUI
old_Rows = screen_Rows;
#endif
screen_Rows = Rows;
screen_Columns = Columns;
- must_redraw = CLEAR; /* need to clear the screen later */
+ must_redraw = CLEAR; // need to clear the screen later
if (doclear)
screenclear2();
#ifdef FEAT_GUI
* Adjust the position of the cursor, for when executing an external
* command.
*/
- if (msg_row >= Rows) /* Rows got smaller */
- msg_row = Rows - 1; /* put cursor at last row */
- else if (Rows > old_Rows) /* Rows got bigger */
- msg_row += Rows - old_Rows; /* put cursor in same place */
- if (msg_col >= Columns) /* Columns got smaller */
- msg_col = Columns - 1; /* put cursor at last column */
+ if (msg_row >= Rows) // Rows got smaller
+ msg_row = Rows - 1; // put cursor at last row
+ else if (Rows > old_Rows) // Rows got bigger
+ msg_row += Rows - old_Rows; // put cursor in same place
+ if (msg_col >= Columns) // Columns got smaller
+ msg_col = Columns - 1; // put cursor at last column
}
#endif
clear_TabPageIdxs();
if (starting == 0 && ++retry_count <= 3)
{
apply_autocmds(EVENT_VIMRESIZED, NULL, NULL, FALSE, curbuf);
- /* In rare cases, autocommands may have altered Rows or Columns,
- * jump back to check if we need to allocate the screen again. */
+ // In rare cases, autocommands may have altered Rows or Columns,
+ // jump back to check if we need to allocate the screen again.
goto retry;
}
}
screenclear(void)
{
check_for_delay(FALSE);
- screenalloc(FALSE); /* allocate screen buffers if size changed */
- screenclear2(); /* clear the screen */
+ screenalloc(FALSE); // allocate screen buffers if size changed
+ screenclear2(); // clear the screen
}
static void
#ifdef FEAT_GUI
if (!gui.in_use)
#endif
- screen_attr = -1; /* force setting the Normal colors */
- screen_stop_highlight(); /* don't want highlighting here */
+ screen_attr = -1; // force setting the Normal colors
+ screen_stop_highlight(); // don't want highlighting here
#ifdef FEAT_CLIPBOARD
- /* disable selection without redrawing it */
+ // disable selection without redrawing it
clip_scroll_selection(9999);
#endif
- /* blank out ScreenLines */
+ // blank out ScreenLines
for (i = 0; i < Rows; ++i)
{
lineclear(LineOffset[i], (int)Columns, 0);
if (can_clear(T_CL))
{
- out_str(T_CL); /* clear the display */
+ out_str(T_CL); // clear the display
clear_cmdline = FALSE;
mode_displayed = FALSE;
}
else
{
- /* can't clear the screen, mark all chars with invalid attributes */
+ // can't clear the screen, mark all chars with invalid attributes
for (i = 0; i < Rows; ++i)
lineinvalid(LineOffset[i], (int)Columns);
clear_cmdline = TRUE;
}
- screen_cleared = TRUE; /* can use contents of ScreenLines now */
+ screen_cleared = TRUE; // can use contents of ScreenLines now
win_rest_invalid(firstwin);
redraw_cmdline = TRUE;
redraw_tabline = TRUE;
- if (must_redraw == CLEAR) /* no need to clear again */
+ if (must_redraw == CLEAR) // no need to clear again
must_redraw = NOT_VALID;
compute_cmdrow();
- msg_row = cmdline_row; /* put cursor on last line for messages */
+ msg_row = cmdline_row; // put cursor on last line for messages
msg_col = 0;
- screen_start(); /* don't know where cursor is now */
- msg_scrolled = 0; /* can't scroll back */
+ screen_start(); // don't know where cursor is now
+ msg_scrolled = 0; // can't scroll back
msg_didany = FALSE;
msg_didout = FALSE;
}
int goto_cost;
int attr;
-#define GOTO_COST 7 /* assume a term_windgoto() takes about 7 chars */
-#define HIGHL_COST 5 /* assume unhighlight takes 5 chars */
+#define GOTO_COST 7 // assume a term_windgoto() takes about 7 chars
+#define HIGHL_COST 5 // assume unhighlight takes 5 chars
#define PLAN_LE 1
#define PLAN_CR 2
#define PLAN_NL 3
#define PLAN_WRITE 4
- /* Can't use ScreenLines unless initialized */
+ // Can't use ScreenLines unless initialized
if (ScreenLines == NULL)
return;
if (col != screen_cur_col || row != screen_cur_row)
{
- /* Check for valid position. */
- if (row < 0) /* window without text lines? */
+ // Check for valid position.
+ if (row < 0) // window without text lines?
row = 0;
if (row >= screen_Rows)
row = screen_Rows - 1;
if (col >= screen_Columns)
col = screen_Columns - 1;
- /* check if no cursor movement is allowed in highlight mode */
+ // check if no cursor movement is allowed in highlight mode
if (screen_attr && *T_MS == NUL)
noinvcurs = HIGHL_COST;
else
* If the cursor is in the same row, bigger col, we can use CR
* or T_LE.
*/
- bs = NULL; /* init for GCC */
+ bs = NULL; // init for GCC
attr = screen_attr;
if (row == screen_cur_row && col < screen_cur_col)
{
- /* "le" is preferred over "bc", because "bc" is obsolete */
+ // "le" is preferred over "bc", because "bc" is obsolete
if (*T_LE)
- bs = T_LE; /* "cursor left" */
+ bs = T_LE; // "cursor left"
else
- bs = T_BC; /* "backspace character (old) */
+ bs = T_BC; // "backspace character (old)
if (*bs)
cost = (screen_cur_col - col) * (int)STRLEN(bs);
else
cost = 999;
- if (col + 1 < cost) /* using CR is less characters */
+ if (col + 1 < cost) // using CR is less characters
{
plan = PLAN_CR;
wouldbe_col = 0;
- cost = 1; /* CR is just one character */
+ cost = 1; // CR is just one character
}
else
{
plan = PLAN_LE;
wouldbe_col = col;
}
- if (noinvcurs) /* will stop highlighting */
+ if (noinvcurs) // will stop highlighting
{
cost += noinvcurs;
attr = 0;
{
plan = PLAN_NL;
wouldbe_col = 0;
- cost = (row - screen_cur_row) * 2; /* CR LF */
- if (noinvcurs) /* will stop highlighting */
+ cost = (row - screen_cur_row) * 2; // CR LF
+ if (noinvcurs) // will stop highlighting
{
cost += noinvcurs;
attr = 0;
--i;
}
if (i != 0)
- cost = 999; /* different attributes, don't do it */
+ cost = 999; // different attributes, don't do it
}
if (enc_utf8)
{
- /* Don't use an UTF-8 char for positioning, it's slow. */
+ // Don't use an UTF-8 char for positioning, it's slow.
for (i = wouldbe_col; i < col; ++i)
if (ScreenLinesUC[LineOffset[row] + i] != 0)
{
windgoto(W_WINROW(curwin) + curwin->w_wrow,
curwin->w_wincol + (
#ifdef FEAT_RIGHTLEFT
- /* With 'rightleft' set and the cursor on a double-wide
- * character, position it on the leftmost column. */
+ // With 'rightleft' set and the cursor on a double-wide
+ // character, position it on the leftmost column.
curwin->w_p_rl ? ((int)curwin->w_width - curwin->w_wcol
- ((has_mbyte
&& (*mb_ptr2cells)(ml_get_cursor()) == 2
int line_count,
int invalid,
int mayclear,
- int clear_attr) /* for clearing lines */
+ int clear_attr) // for clearing lines
{
int retval;
return retval;
}
- if (wp->w_next != NULL && p_tf) /* don't delete/insert on fast terminal */
+ if (wp->w_next != NULL && p_tf) // don't delete/insert on fast terminal
return FAIL;
return MAYBE;
int line_count,
int end,
int clear_attr,
- win_T *wp) /* NULL or window to use width from */
+ win_T *wp) // NULL or window to use width from
{
int i;
int j;
screen_del_lines(off, end - line_count, line_count, end, FALSE, 0, wp);
#ifdef FEAT_CLIPBOARD
- /* Remove a modeless selection when inserting lines halfway the screen
- * or not the full width of the screen. */
+ // Remove a modeless selection when inserting lines halfway the screen
+ // or not the full width of the screen.
if (off + row > 0 || (wp != NULL && wp->w_width != Columns))
clip_clear_selection(&clip_star);
else
#endif
#ifdef FEAT_GUI
- /* Don't update the GUI cursor here, ScreenLines[] is invalid until the
- * scrolling is actually carried out. */
+ // Don't update the GUI cursor here, ScreenLines[] is invalid until the
+ // scrolling is actually carried out.
gui_dont_update_cursor(row + off <= gui.cursor_row);
#endif
if (wp != NULL && wp->w_wincol != 0 && *T_CSV != NUL && *T_CCS == NUL)
cursor_col = wp->w_wincol;
- if (*T_CCS != NUL) /* cursor relative to region */
+ if (*T_CCS != NUL) // cursor relative to region
cursor_row = row;
else
cursor_row = row + off;
{
if (wp != NULL && wp->w_width != Columns)
{
- /* need to copy part of a line */
+ // need to copy part of a line
j = end - 1 - i;
while ((j -= line_count) >= row)
linecopy(j + line_count, j, wp);
if (clear_attr != 0)
screen_start_highlight(clear_attr);
- /* redraw the characters */
+ // redraw the characters
if (type == USE_REDRAW)
redraw_block(row, end, wp);
else if (type == USE_T_CAL)
{
term_append_lines(line_count);
- screen_start(); /* don't know where cursor is now */
+ screen_start(); // don't know where cursor is now
}
else
{
windgoto(cursor_row, cursor_col);
out_str(T_AL);
}
- else /* type == USE_T_SR */
+ else // type == USE_T_SR
out_str(T_SR);
- screen_start(); /* don't know where cursor is now */
+ screen_start(); // don't know where cursor is now
}
}
{
windgoto(off + i, cursor_col);
out_str(T_CE);
- screen_start(); /* don't know where cursor is now */
+ screen_start(); // don't know where cursor is now
}
}
#ifdef FEAT_GUI
gui_can_update_cursor();
if (gui.in_use)
- out_flush(); /* always flush after a scroll */
+ out_flush(); // always flush after a scroll
#endif
return OK;
}
int row,
int line_count,
int end,
- int force, /* even when line_count > p_ttyscroll */
- int clear_attr, /* used for clearing lines */
- win_T *wp UNUSED) /* NULL or window to use width from */
+ int force, // even when line_count > p_ttyscroll
+ int clear_attr, // used for clearing lines
+ win_T *wp UNUSED) // NULL or window to use width from
{
int j;
int i;
int cursor_row;
int cursor_col = 0;
int cursor_end;
- int result_empty; /* result is empty until end of region */
- int can_delete; /* deleting line codes can be used */
+ int result_empty; // result is empty until end of region
+ int can_delete; // deleting line codes can be used
int type;
/*
#else
else if (row == 0 && (
#ifndef AMIGA
- /* On the Amiga, somehow '\n' on the last line doesn't always scroll
- * up, so use delete-line command */
+ // On the Amiga, somehow '\n' on the last line doesn't always scroll
+ // up, so use delete-line command
line_count == 1 ||
#endif
*T_CDL == NUL))
return FAIL;
#ifdef FEAT_CLIPBOARD
- /* Remove a modeless selection when deleting lines halfway the screen or
- * not the full width of the screen. */
+ // Remove a modeless selection when deleting lines halfway the screen or
+ // not the full width of the screen.
if (off + row > 0 || (wp != NULL && wp->w_width != Columns))
clip_clear_selection(&clip_star);
else
#endif
#ifdef FEAT_GUI
- /* Don't update the GUI cursor here, ScreenLines[] is invalid until the
- * scrolling is actually carried out. */
+ // Don't update the GUI cursor here, ScreenLines[] is invalid until the
+ // scrolling is actually carried out.
gui_dont_update_cursor(gui.cursor_row >= row + off
&& gui.cursor_row < end + off);
#endif
if (wp != NULL && wp->w_wincol != 0 && *T_CSV != NUL && *T_CCS == NUL)
cursor_col = wp->w_wincol;
- if (*T_CCS != NUL) /* cursor relative to region */
+ if (*T_CCS != NUL) // cursor relative to region
{
cursor_row = row;
cursor_end = end;
{
if (wp != NULL && wp->w_width != Columns)
{
- /* need to copy part of a line */
+ // need to copy part of a line
j = row + i;
while ((j += line_count) <= end - 1)
linecopy(j - line_count, j, wp);
}
else
{
- /* whole width, moving the line pointers is faster */
+ // whole width, moving the line pointers is faster
j = row + i;
temp = LineOffset[j];
while ((j += line_count) <= end - 1)
if (clear_attr != 0)
screen_start_highlight(clear_attr);
- /* redraw the characters */
+ // redraw the characters
if (type == USE_REDRAW)
redraw_block(row, end, wp);
- else if (type == USE_T_CD) /* delete the lines */
+ else if (type == USE_T_CD) // delete the lines
{
windgoto(cursor_row, cursor_col);
out_str(T_CD);
- screen_start(); /* don't know where cursor is now */
+ screen_start(); // don't know where cursor is now
}
else if (type == USE_T_CDL)
{
windgoto(cursor_row, cursor_col);
term_delete_lines(line_count);
- screen_start(); /* don't know where cursor is now */
+ screen_start(); // don't know where cursor is now
}
/*
* Deleting lines at top of the screen or scroll region: Just scroll
{
windgoto(cursor_end - 1, cursor_col);
for (i = line_count; --i >= 0; )
- out_char('\n'); /* cursor will remain on same line */
+ out_char('\n'); // cursor will remain on same line
}
else
{
if (type == USE_T_DL)
{
windgoto(cursor_row, cursor_col);
- out_str(T_DL); /* delete a line */
+ out_str(T_DL); // delete a line
}
- else /* type == USE_T_CE */
+ else // type == USE_T_CE
{
windgoto(cursor_row + i, cursor_col);
- out_str(T_CE); /* erase a line */
+ out_str(T_CE); // erase a line
}
- screen_start(); /* don't know where cursor is now */
+ screen_start(); // don't know where cursor is now
}
}
for (i = line_count; i > 0; --i)
{
windgoto(cursor_end - i, cursor_col);
- out_str(T_CE); /* erase a line */
- screen_start(); /* don't know where cursor is now */
+ out_str(T_CE); // erase a line
+ screen_start(); // don't know where cursor is now
}
}
#ifdef FEAT_GUI
gui_can_update_cursor();
if (gui.in_use)
- out_flush(); /* always flush after a scroll */
+ out_flush(); // always flush after a scroll
#endif
return OK;
nwr_save = need_wait_return;
- /* wait a bit before overwriting an important message */
+ // wait a bit before overwriting an important message
check_for_delay(FALSE);
- /* if the cmdline is more than one line high, erase top lines */
+ // if the cmdline is more than one line high, erase top lines
need_clear = clear_cmdline;
if (clear_cmdline && cmdline_row < Rows - 1)
- msg_clr_cmdline(); /* will reset clear_cmdline */
+ msg_clr_cmdline(); // will reset clear_cmdline
- /* Position on the last line in the window, column 0 */
+ // Position on the last line in the window, column 0
msg_pos_mode();
cursor_off();
- attr = HL_ATTR(HLF_CM); /* Highlight mode */
+ attr = HL_ATTR(HLF_CM); // Highlight mode
if (do_mode)
{
msg_puts_attr("--", attr);
im_get_status()
# endif
)
-# ifdef FEAT_GUI_GTK /* most of the time, it's not XIM being used */
+# ifdef FEAT_GUI_GTK // most of the time, it's not XIM being used
msg_puts_attr(" IM", attr);
# else
msg_puts_attr(" XIM", attr);
# endif
#endif
- /* CTRL-X in Insert mode */
+ // CTRL-X in Insert mode
if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU))
{
- /* These messages can get long, avoid a wrap in a narrow
- * window. Prefer showing edit_submode_extra. */
+ // These messages can get long, avoid a wrap in a narrow
+ // window. Prefer showing edit_submode_extra.
length = (Rows - msg_row) * Columns - 3;
if (edit_submode_extra != NULL)
length -= vim_strsize(edit_submode_extra);
}
if (edit_submode_extra != NULL)
{
- msg_puts_attr(" ", attr); /* add a space in between */
+ msg_puts_attr(" ", attr); // add a space in between
if ((int)edit_submode_highl < (int)HLF_COUNT)
sub_attr = HL_ATTR(edit_submode_highl);
else
{
char *p;
- /* Don't concatenate separate words to avoid translation
- * problems. */
+ // Don't concatenate separate words to avoid translation
+ // problems.
switch ((VIsual_select ? 4 : 0)
+ (VIsual_mode == Ctrl_V) * 2
+ (VIsual_mode == 'V'))
mode_displayed = TRUE;
if (need_clear || clear_cmdline || redraw_mode)
msg_clr_eos();
- msg_didout = FALSE; /* overwrite this message */
+ msg_didout = FALSE; // overwrite this message
length = msg_col;
msg_col = 0;
- need_wait_return = nwr_save; /* never ask for hit-return for this */
+ need_wait_return = nwr_save; // never ask for hit-return for this
}
else if (clear_cmdline && msg_silent == 0)
- /* Clear the whole command line. Will reset "clear_cmdline". */
+ // Clear the whole command line. Will reset "clear_cmdline".
msg_clr_cmdline();
else if (redraw_mode)
{
}
#ifdef FEAT_CMDL_INFO
- /* In Visual mode the size of the selected area must be redrawn. */
+ // In Visual mode the size of the selected area must be redrawn.
if (VIsual_active)
clear_showcmd();
- /* If the last window has no status line, the ruler is after the mode
- * message and must be redrawn */
+ // If the last window has no status line, the ruler is after the mode
+ // message and must be redrawn
if (redrawing() && lastwin->w_status_height == 0)
win_redr_ruler(lastwin, TRUE, FALSE);
#endif
* Don't delete it right now, when not redrawing or inside a mapping.
*/
if (!redrawing() || (!force && char_avail() && !KeyTyped))
- redraw_cmdline = TRUE; /* delete mode later */
+ redraw_cmdline = TRUE; // delete mode later
else
clearmode();
}
redraw_tabline = FALSE;
#ifdef FEAT_GUI_TABLINE
- /* Take care of a GUI tabline. */
+ // Take care of a GUI tabline.
if (gui_use_tabline())
{
gui_update_tabline();
#if defined(FEAT_STL_OPT)
clear_TabPageIdxs();
- /* Use the 'tabline' option if it's set. */
+ // Use the 'tabline' option if it's set.
if (*p_tal != NUL)
{
int saved_did_emsg = did_emsg;
- /* Check for an error. If there is one we would loop in redrawing the
- * screen. Avoid that by making 'tabline' empty. */
+ // Check for an error. If there is one we would loop in redrawing the
+ // screen. Avoid that by making 'tabline' empty.
did_emsg = FALSE;
win_redr_custom(NULL, FALSE);
if (did_emsg)
room = scol - col + tabwidth - 1;
if (room > 0)
{
- /* Get buffer name in NameBuff[] */
+ // Get buffer name in NameBuff[]
get_trans_bufname(cwp->w_buffer);
shorten_dir(NameBuff);
len = vim_strsize(NameBuff);
}
screen_putchar(' ', 0, col++, attr);
- /* Store the tab page number in TabPageIdxs[], so that
- * jump_to_mouse() knows where each one is. */
+ // Store the tab page number in TabPageIdxs[], so that
+ // jump_to_mouse() knows where each one is.
++tabcount;
while (scol < col)
TabPageIdxs[scol++] = tabcount;
c = ' ';
screen_fill(0, 1, col, (int)Columns, c, c, attr_fill);
- /* Put an "X" for closing the current tab if there are several. */
+ // Put an "X" for closing the current tab if there are several.
if (first_tabpage->tp_next != NULL)
{
screen_putchar('X', 0, (int)Columns - 1, attr_nosel);
}
}
- /* Reset the flag here again, in case evaluating 'tabline' causes it to be
- * set. */
+ // Reset the flag here again, in case evaluating 'tabline' causes it to be
+ // set.
redraw_tabline = FALSE;
}
*attr = HL_ATTR(HLF_SNC);
fill = fill_stlnc;
}
- /* Use fill when there is highlighting, and highlighting of current
- * window differs, or the fillchars differ, or this is not the
- * current window */
+ // Use fill when there is highlighting, and highlighting of current
+ // window differs, or the fillchars differ, or this is not the
+ // current window
if (*attr != 0 && ((HL_ATTR(HLF_S) != HL_ATTR(HLF_SNC)
|| wp != curwin || ONE_WINDOW)
|| (fill_stl != fill_stlnc)))
linenr_T lnum;
if (wp->w_p_rnu && !wp->w_p_nu)
- /* cursor line shows "0" */
+ // cursor line shows "0"
lnum = wp->w_height;
else
- /* cursor line shows absolute line number */
+ // cursor line shows absolute line number
lnum = wp->w_buffer->b_ml.ml_line_count;
if (lnum == wp->w_nrwidth_line_count && wp->w_nuw_cached == wp->w_p_nuw)
++n;
} while (lnum > 0);
- /* 'numberwidth' gives the minimal width plus one */
+ // 'numberwidth' gives the minimal width plus one
if (n < wp->w_p_nuw - 1)
n = wp->w_p_nuw - 1;
*/
static spat_T spats[2] =
{
- {NULL, TRUE, FALSE, {'/', 0, 0, 0L}}, /* last used search pat */
- {NULL, TRUE, FALSE, {'/', 0, 0, 0L}} /* last used substitute pat */
+ {NULL, TRUE, FALSE, {'/', 0, 0, 0L}}, // last used search pat
+ {NULL, TRUE, FALSE, {'/', 0, 0, 0L}} // last used substitute pat
};
-static int last_idx = 0; /* index in spats[] for RE_LAST */
+static int last_idx = 0; // index in spats[] for RE_LAST
-static char_u lastc[2] = {NUL, NUL}; /* last character searched for */
-static int lastcdir = FORWARD; /* last direction of character search */
-static int last_t_cmd = TRUE; /* last search t_cmd */
+static char_u lastc[2] = {NUL, NUL}; // last character searched for
+static int lastcdir = FORWARD; // last direction of character search
+static int last_t_cmd = TRUE; // last search t_cmd
static char_u lastc_bytes[MB_MAXBYTES + 1];
-static int lastc_bytelen = 1; /* >1 for multi-byte char */
+static int lastc_bytelen = 1; // >1 for multi-byte char
-/* copy of spats[], for keeping the search patterns while executing autocmds */
+// copy of spats[], for keeping the search patterns while executing autocmds
static spat_T saved_spats[2];
# ifdef FEAT_SEARCH_EXTRA
static int saved_spats_last_idx = 0;
static int saved_spats_no_hlsearch = 0;
# endif
-static char_u *mr_pattern = NULL; /* pattern used by search_regcomp() */
+static char_u *mr_pattern = NULL; // pattern used by search_regcomp()
#ifdef FEAT_RIGHTLEFT
-static int mr_pattern_alloced = FALSE; /* mr_pattern was allocated */
+static int mr_pattern_alloced = FALSE; // mr_pattern was allocated
#endif
#ifdef FEAT_FIND_ID
*/
typedef struct SearchedFile
{
- FILE *fp; /* File pointer */
- char_u *name; /* Full name of file */
- linenr_T lnum; /* Line we were up to in file */
- int matched; /* Found a match in this file */
+ FILE *fp; // File pointer
+ char_u *name; // Full name of file
+ linenr_T lnum; // Line we were up to in file
+ int matched; // Found a match in this file
} SearchedFile;
#endif
int pat_save,
int pat_use,
int options,
- regmmatch_T *regmatch) /* return: pattern and ignore-case flag */
+ regmmatch_T *regmatch) // return: pattern and ignore-case flag
{
int magic;
int i;
i = last_idx;
else
i = pat_use;
- if (spats[i].pat == NULL) /* pattern was never defined */
+ if (spats[i].pat == NULL) // pattern was never defined
{
if (pat_use == RE_SUBST)
emsg(_(e_nopresub));
magic = spats[i].magic;
no_smartcase = spats[i].no_scs;
}
- else if (options & SEARCH_HIS) /* put new pattern in history */
+ else if (options & SEARCH_HIS) // put new pattern in history
add_to_history(HIST_SEARCH, pat, TRUE, NUL);
#ifdef FEAT_RIGHTLEFT
rev_pattern = reverse_text(pat);
if (rev_pattern == NULL)
- mr_pattern = pat; /* out of memory, keep normal pattern. */
+ mr_pattern = pat; // out of memory, keep normal pattern.
else
{
mr_pattern = rev_pattern;
*/
if (!(options & SEARCH_KEEP) && !cmdmod.keeppatterns)
{
- /* search or global command */
+ // search or global command
if (pat_save == RE_SEARCH || pat_save == RE_BOTH)
save_re_pat(RE_SEARCH, pat, magic);
- /* substitute or global command */
+ // substitute or global command
if (pat_save == RE_SUBST || pat_save == RE_BOTH)
save_re_pat(RE_SUBST, pat, magic);
}
spats[idx].no_scs = no_smartcase;
last_idx = idx;
#ifdef FEAT_SEARCH_EXTRA
- /* If 'hlsearch' set and search pat changed: need redraw. */
+ // If 'hlsearch' set and search pat changed: need redraw.
if (p_hls)
redraw_all_later(SOME_VALID);
set_no_hlsearch(FALSE);
}
else if (*p == '\\')
{
- if (p[1] == '_' && p[2] != NUL) /* skip "\_X" */
+ if (p[1] == '_' && p[2] != NUL) // skip "\_X"
p += 3;
- else if (p[1] == '%' && p[2] != NUL) /* skip "\%X" */
+ else if (p[1] == '%' && p[2] != NUL) // skip "\%X"
p += 3;
- else if (p[1] != NUL) /* skip "\X" */
+ else if (p[1] != NUL) // skip "\X"
p += 2;
else
p += 1;
int setlast)
{
vim_free(spats[idx].pat);
- /* An empty string means that nothing should be matched. */
+ // An empty string means that nothing should be matched.
if (*s == NUL)
spats[idx].pat = NULL;
else
# endif
}
# ifdef FEAT_SEARCH_EXTRA
- /* If 'hlsearch' set and search pat changed: need redraw. */
+ // If 'hlsearch' set and search pat changed: need redraw.
if (p_hls && idx == last_idx && !no_hlsearch)
redraw_all_later(SOME_VALID);
# endif
regmatch->regprog = NULL;
return;
}
- ++emsg_off; /* So it doesn't beep if bad expr */
+ ++emsg_off; // So it doesn't beep if bad expr
(void)search_regcomp((char_u *)"", 0, last_idx, SEARCH_KEEP, regmatch);
--emsg_off;
}
searchit_arg_T *extra_arg) // optional extra arguments, can be NULL
{
int found;
- linenr_T lnum; /* no init to shut up Apollo cc */
+ linenr_T lnum; // no init to shut up Apollo cc
colnr_T col;
regmmatch_T regmatch;
char_u *ptr;
* find the string
*/
called_emsg = FALSE;
- do /* loop for count */
+ do // loop for count
{
- /* When not accepting a match at the start position set "extra_col" to
- * a non-zero value. Don't do that when starting at MAXCOL, since
- * MAXCOL + 1 is zero. */
+ // When not accepting a match at the start position set "extra_col" to
+ // a non-zero value. Don't do that when starting at MAXCOL, since
+ // MAXCOL + 1 is zero.
if (pos->col == MAXCOL)
start_char_len = 0;
- /* Watch out for the "col" being MAXCOL - 2, used in a closed fold. */
+ // Watch out for the "col" being MAXCOL - 2, used in a closed fold.
else if (has_mbyte
&& pos->lnum >= 1 && pos->lnum <= buf->b_ml.ml_line_count
&& pos->col < MAXCOL - 2)
extra_col = 0;
}
- start_pos = *pos; /* remember start pos for detecting no match */
- found = 0; /* default: not found */
- at_first_line = TRUE; /* default: start in first line */
- if (pos->lnum == 0) /* correct lnum for when starting in line 0 */
+ start_pos = *pos; // remember start pos for detecting no match
+ found = 0; // default: not found
+ at_first_line = TRUE; // default: start in first line
+ if (pos->lnum == 0) // correct lnum for when starting in line 0
{
pos->lnum = 1;
pos->col = 0;
- at_first_line = FALSE; /* not in first line now */
+ at_first_line = FALSE; // not in first line now
}
/*
else
lnum = pos->lnum;
- for (loop = 0; loop <= 1; ++loop) /* loop twice if 'wrapscan' set */
+ for (loop = 0; loop <= 1; ++loop) // loop twice if 'wrapscan' set
{
for ( ; lnum > 0 && lnum <= buf->b_ml.ml_line_count;
lnum += dir, at_first_line = FALSE)
{
- /* Stop after checking "stop_lnum", if it's set. */
+ // Stop after checking "stop_lnum", if it's set.
if (stop_lnum != 0 && (dir == FORWARD
? lnum > stop_lnum : lnum < stop_lnum))
break;
#ifdef FEAT_RELTIME
- /* Stop after passing the "tm" time limit. */
+ // Stop after passing the "tm" time limit.
if (tm != NULL && profile_passed_limit(tm))
break;
#endif
NULL, NULL
#endif
);
- /* Abort searching on an error (e.g., out of stack). */
+ // Abort searching on an error (e.g., out of stack).
if (called_emsg
#ifdef FEAT_RELTIME
|| (timed_out != NULL && *timed_out)
break;
if (nmatched > 0)
{
- /* match may actually be in another line when using \zs */
+ // match may actually be in another line when using \zs
matchpos = regmatch.startpos[0];
endpos = regmatch.endpos[0];
#ifdef FEAT_EVAL
submatch = first_submatch(®match);
#endif
- /* "lnum" may be past end of buffer for "\n\zs". */
+ // "lnum" may be past end of buffer for "\n\zs".
if (lnum + matchpos.lnum > buf->b_ml.ml_line_count)
ptr = (char_u *)"";
else
{
if (nmatched > 1)
{
- /* end is in next line, thus no match in
- * this line */
+ // end is in next line, thus no match in
+ // this line
match_ok = FALSE;
break;
}
matchcol = endpos.col;
- /* for empty match: advance one char */
+ // for empty match: advance one char
if (matchcol == matchpos.col
&& ptr[matchcol] != NUL)
{
submatch = first_submatch(®match);
# endif
- /* Need to get the line pointer again, a
- * multi-line search may have made it invalid. */
+ // Need to get the line pointer again, a
+ // multi-line search may have made it invalid.
ptr = ml_get_buf(buf, lnum + matchpos.lnum, FALSE);
}
if (!match_ok)
match_ok = FALSE;
for (;;)
{
- /* Remember a position that is before the start
- * position, we use it if it's the last match in
- * the line. Always accept a position after
- * wrapping around. */
+ // Remember a position that is before the start
+ // position, we use it if it's the last match in
+ // the line. Always accept a position after
+ // wrapping around.
if (loop
|| ((options & SEARCH_END)
? (lnum + regmatch.endpos[0].lnum
if (nmatched > 1)
break;
matchcol = endpos.col;
- /* for empty match: advance one char */
+ // for empty match: advance one char
if (matchcol == matchpos.col
&& ptr[matchcol] != NUL)
{
}
else
{
- /* Stop when the match is in a next line. */
+ // Stop when the match is in a next line.
if (matchpos.lnum > 0)
break;
matchcol = matchpos.col;
)) == 0)
{
#ifdef FEAT_RELTIME
- /* If the search timed out, we did find a match
- * but it might be the wrong one, so that's not
- * OK. */
+ // If the search timed out, we did find a match
+ // but it might be the wrong one, so that's not
+ // OK.
if (timed_out != NULL && *timed_out)
match_ok = FALSE;
#endif
break;
}
- /* Need to get the line pointer again, a
- * multi-line search may have made it invalid. */
+ // Need to get the line pointer again, a
+ // multi-line search may have made it invalid.
ptr = ml_get_buf(buf, lnum + matchpos.lnum, FALSE);
}
continue;
}
- /* With the SEARCH_END option move to the last character
- * of the match. Don't do it for an empty match, end
- * should be same as start then. */
+ // With the SEARCH_END option move to the last character
+ // of the match. Don't do it for an empty match, end
+ // should be same as start then.
if ((options & SEARCH_END) && !(options & SEARCH_NOOF)
&& !(matchpos.lnum == endpos.lnum
&& matchpos.col == endpos.col))
{
- /* For a match in the first column, set the position
- * on the NUL in the previous line. */
+ // For a match in the first column, set the position
+ // on the NUL in the previous line.
pos->lnum = lnum + endpos.lnum;
pos->col = endpos.col;
if (endpos.col == 0)
{
- if (pos->lnum > 1) /* just in case */
+ if (pos->lnum > 1) // just in case
{
--pos->lnum;
pos->col = (colnr_T)STRLEN(ml_get_buf(buf,
found = 1;
first_match = FALSE;
- /* Set variables used for 'incsearch' highlighting. */
+ // Set variables used for 'incsearch' highlighting.
search_match_lines = endpos.lnum - matchpos.lnum;
search_match_endcol = endpos.col;
break;
}
- line_breakcheck(); /* stop if ctrl-C typed */
+ line_breakcheck(); // stop if ctrl-C typed
if (got_int)
break;
#ifdef FEAT_SEARCH_EXTRA
- /* Cancel searching if a character was typed. Used for
- * 'incsearch'. Don't check too often, that would slowdown
- * searching too much. */
+ // Cancel searching if a character was typed. Used for
+ // 'incsearch'. Don't check too often, that would slowdown
+ // searching too much.
if ((options & SEARCH_PEEK)
&& ((lnum - pos->lnum) & 0x3f) == 0
&& char_avail())
#endif
if (loop && lnum == start_pos.lnum)
- break; /* if second loop, stop where started */
+ break; // if second loop, stop where started
}
at_first_line = FALSE;
* is redrawn. The keep_msg is cleared whenever another message is
* written.
*/
- if (dir == BACKWARD) /* start second loop at the other end */
+ if (dir == BACKWARD) // start second loop at the other end
lnum = buf->b_ml.ml_line_count;
else
lnum = 1;
)
break;
}
- while (--count > 0 && found); /* stop after count matches or no match */
+ while (--count > 0 && found); // stop after count matches or no match
vim_regfree(regmatch.regprog);
called_emsg |= save_called_emsg;
- if (!found) /* did not find it */
+ if (!found) // did not find it
{
if (got_int)
emsg(_(e_interr));
return FAIL;
}
- /* A pattern like "\n\zs" may go past the last line. */
+ // A pattern like "\n\zs" may go past the last line.
if (pos->lnum > buf->b_ml.ml_line_count)
{
pos->lnum = buf->b_ml.ml_line_count;
*/
int
do_search(
- oparg_T *oap, /* can be NULL */
- int dirc, /* '/' or '?' */
+ oparg_T *oap, // can be NULL
+ int dirc, // '/' or '?'
char_u *pat,
long count,
int options,
searchit_arg_T *sia) // optional arguments or NULL
{
- pos_T pos; /* position of the last match */
+ pos_T pos; // position of the last match
char_u *searchstr;
soffset_T old_off;
- int retval; /* Return value */
+ int retval; // Return value
char_u *p;
long c;
char_u *dircp;
*/
old_off = spats[0].off;
- pos = curwin->w_cursor; /* start searching at the cursor position */
+ pos = curwin->w_cursor; // start searching at the cursor position
/*
* Find out the direction of the search.
if (options & SEARCH_REV)
{
#ifdef MSWIN
- /* There is a bug in the Visual C++ 2.2 compiler which means that
- * dirc always ends up being '/' */
+ // There is a bug in the Visual C++ 2.2 compiler which means that
+ // dirc always ends up being '/'
dirc = (dirc == '/') ? '?' : '/';
#else
if (dirc == '/')
}
#ifdef FEAT_FOLDING
- /* If the cursor is in a closed fold, don't find another match in the same
- * fold. */
+ // If the cursor is in a closed fold, don't find another match in the same
+ // fold.
if (dirc == '/')
{
if (hasFolding(pos.lnum, NULL, &pos.lnum))
- pos.col = MAXCOL - 2; /* avoid overflow when adding 1 */
+ pos.col = MAXCOL - 2; // avoid overflow when adding 1
}
else
{
searchstr = pat;
dircp = NULL;
- /* use previous pattern */
+ // use previous pattern
if (pat == NULL || *pat == NUL || *pat == dirc)
{
- if (spats[RE_SEARCH].pat == NULL) /* no previous pattern */
+ if (spats[RE_SEARCH].pat == NULL) // no previous pattern
{
searchstr = spats[RE_SUBST].pat;
if (searchstr == NULL)
}
else
{
- /* make search_regcomp() use spats[RE_SEARCH].pat */
+ // make search_regcomp() use spats[RE_SEARCH].pat
searchstr = (char_u *)"";
}
}
- if (pat != NULL && *pat != NUL) /* look for (new) offset */
+ if (pat != NULL && *pat != NUL) // look for (new) offset
{
/*
* Find end of regular expression.
p = skip_regexp(pat, dirc, (int)p_magic, &strcopy);
if (strcopy != ps)
{
- /* made a copy of "pat" to change "\?" to "?" */
+ // made a copy of "pat" to change "\?" to "?"
searchcmdlen += (int)(STRLEN(pat) - STRLEN(strcopy));
pat = strcopy;
searchstr = strcopy;
}
if (*p == dirc)
{
- dircp = p; /* remember where we put the NUL */
+ dircp = p; // remember where we put the NUL
*p++ = NUL;
}
spats[0].off.line = FALSE;
else if ((options & SEARCH_OPT) &&
(*p == 'e' || *p == 's' || *p == 'b'))
{
- if (*p == 'e') /* end */
+ if (*p == 'e') // end
spats[0].off.end = SEARCH_END;
++p;
}
- if (VIM_ISDIGIT(*p) || *p == '+' || *p == '-') /* got an offset */
+ if (VIM_ISDIGIT(*p) || *p == '+' || *p == '-') // got an offset
{
- /* 'nr' or '+nr' or '-nr' */
+ // 'nr' or '+nr' or '-nr'
if (VIM_ISDIGIT(*p) || VIM_ISDIGIT(*(p + 1)))
spats[0].off.off = atol((char *)p);
- else if (*p == '-') /* single '-' */
+ else if (*p == '-') // single '-'
spats[0].off.off = -1;
- else /* single '+' */
+ else // single '+'
spats[0].off.off = 1;
++p;
- while (VIM_ISDIGIT(*p)) /* skip number */
+ while (VIM_ISDIGIT(*p)) // skip number
++p;
}
- /* compute length of search command for get_address() */
+ // compute length of search command for get_address()
searchcmdlen += (int)(p - pat);
- pat = p; /* put pat after search command */
+ pat = p; // put pat after search command
}
if ((options & SEARCH_ECHO) && messaging() &&
for (c = spats[0].off.off; c; --c)
if (decl(&pos) == -1)
break;
- if (c) /* at start of buffer */
+ if (c) // at start of buffer
{
- pos.lnum = 0; /* allow lnum == 0 here */
+ pos.lnum = 0; // allow lnum == 0 here
pos.col = MAXCOL;
}
}
for (c = spats[0].off.off; c; ++c)
if (incl(&pos) == -1)
break;
- if (c) /* at end of buffer */
+ if (c) // at end of buffer
{
pos.lnum = curbuf->b_ml.ml_line_count + 1;
pos.col = 0;
goto end_do_search;
}
if (spats[0].off.end && oap != NULL)
- oap->inclusive = TRUE; /* 'e' includes last character */
+ oap->inclusive = TRUE; // 'e' includes last character
- retval = 1; /* pattern found */
+ retval = 1; // pattern found
/*
* Add character and/or line offset
{
pos_T org_pos = pos;
- if (spats[0].off.line) /* Add the offset to the line number. */
+ if (spats[0].off.line) // Add the offset to the line number.
{
c = pos.lnum + spats[0].off.off;
if (c < 1)
pos.lnum = c;
pos.col = 0;
- retval = 2; /* pattern found, line offset added */
+ retval = 2; // pattern found, line offset added
}
- else if (pos.col < MAXCOL - 2) /* just in case */
+ else if (pos.col < MAXCOL - 2) // just in case
{
- /* to the right, check for end of file */
+ // to the right, check for end of file
c = spats[0].off.off;
if (c > 0)
{
if (incl(&pos) == -1)
break;
}
- /* to the left, check for start of file */
+ // to the left, check for start of file
else
{
while (c++ < 0)
p = skipwhite(ptr);
pos->col = (colnr_T) (p - ptr);
- /* when adding lines the matching line may be empty but it is not
- * ignored because we are interested in the next line -- Acevedo */
+ // when adding lines the matching line may be empty but it is not
+ // ignored because we are interested in the next line -- Acevedo
if ((compl_cont_status & CONT_ADDING)
&& !(compl_cont_status & CONT_SOL))
{
if ((p_ic ? MB_STRICMP(p, pat) : STRCMP(p, pat)) == 0)
return OK;
}
- else if (*p != NUL) /* ignore empty lines */
- { /* expanding lines or words */
+ else if (*p != NUL) // ignore empty lines
+ { // expanding lines or words
if ((p_ic ? MB_STRNICMP(p, pat, compl_length)
: STRNCMP(p, pat, compl_length)) == 0)
return OK;
int
searchc(cmdarg_T *cap, int t_cmd)
{
- int c = cap->nchar; /* char to search for */
- int dir = cap->arg; /* TRUE for searching forward */
- long count = cap->count1; /* repeat count */
+ int c = cap->nchar; // char to search for
+ int dir = cap->arg; // TRUE for searching forward
+ long count = cap->count1; // repeat count
int col;
char_u *p;
int len;
int stop = TRUE;
- if (c != NUL) /* normal search: remember args for repeat */
+ if (c != NUL) // normal search: remember args for repeat
{
- if (!KeyStuffed) /* don't remember when redoing */
+ if (!KeyStuffed) // don't remember when redoing
{
*lastc = c;
set_csearch_direction(dir);
}
}
}
- else /* repeat previous search */
+ else // repeat previous search
{
if (*lastc == NUL && lastc_bytelen == 1)
return FAIL;
- if (dir) /* repeat in opposite direction */
+ if (dir) // repeat in opposite direction
dir = -lastcdir;
else
dir = lastcdir;
t_cmd = last_t_cmd;
c = *lastc;
- /* For multi-byte re-use last lastc_bytes[] and lastc_bytelen. */
+ // For multi-byte re-use last lastc_bytes[] and lastc_bytelen.
- /* Force a move of at least one char, so ";" and "," will move the
- * cursor, even if the cursor is right in front of char we are looking
- * at. */
+ // Force a move of at least one char, so ";" and "," will move the
+ // cursor, even if the cursor is right in front of char we are looking
+ // at.
if (vim_strchr(p_cpo, CPO_SCOLON) == NULL && count == 1 && t_cmd)
stop = FALSE;
}
if (t_cmd)
{
- /* backup to before the character (possibly double-byte) */
+ // backup to before the character (possibly double-byte)
col -= dir;
if (has_mbyte)
{
if (dir < 0)
- /* Landed on the search char which is lastc_bytelen long */
+ // Landed on the search char which is lastc_bytelen long
col += lastc_bytelen - 1;
else
- /* To previous char, which may be multi-byte. */
+ // To previous char, which may be multi-byte.
col -= (*mb_head_off)(p, p + col);
}
}
int flags,
int maxtravel)
{
- static pos_T pos; /* current search position */
- int findc = 0; /* matching brace */
+ static pos_T pos; // current search position
+ int findc = 0; // matching brace
int c;
- int count = 0; /* cumulative number of braces */
- int backwards = FALSE; /* init for gcc */
- int raw_string = FALSE; /* search for raw string */
- int inquote = FALSE; /* TRUE when inside quotes */
- char_u *linep; /* pointer to current line */
+ int count = 0; // cumulative number of braces
+ int backwards = FALSE; // init for gcc
+ int raw_string = FALSE; // search for raw string
+ int inquote = FALSE; // TRUE when inside quotes
+ char_u *linep; // pointer to current line
char_u *ptr;
- int do_quotes; /* check for quotes in current line */
- int at_start; /* do_quotes value at start position */
- int hash_dir = 0; /* Direction searched for # things */
- int comment_dir = 0; /* Direction searched for comments */
- pos_T match_pos; /* Where last slash-star was found */
- int start_in_quotes; /* start position is in quotes */
- int traveled = 0; /* how far we've searched so far */
- int ignore_cend = FALSE; /* ignore comment end */
- int cpo_match; /* vi compatible matching */
- int cpo_bsl; /* don't recognize backslashes */
- int match_escaped = 0; /* search for escaped match */
- int dir; /* Direction to search */
- int comment_col = MAXCOL; /* start of / / comment */
+ int do_quotes; // check for quotes in current line
+ int at_start; // do_quotes value at start position
+ int hash_dir = 0; // Direction searched for # things
+ int comment_dir = 0; // Direction searched for comments
+ pos_T match_pos; // Where last slash-star was found
+ int start_in_quotes; // start position is in quotes
+ int traveled = 0; // how far we've searched so far
+ int ignore_cend = FALSE; // ignore comment end
+ int cpo_match; // vi compatible matching
+ int cpo_bsl; // don't recognize backslashes
+ int match_escaped = 0; // search for escaped match
+ int dir; // Direction to search
+ int comment_col = MAXCOL; // start of / / comment
#ifdef FEAT_LISP
- int lispcomm = FALSE; /* inside of Lisp-style comment */
- int lisp = curbuf->b_p_lisp; /* engage Lisp-specific hacks ;) */
+ int lispcomm = FALSE; // inside of Lisp-style comment
+ int lisp = curbuf->b_p_lisp; // engage Lisp-specific hacks ;)
#endif
pos = curwin->w_cursor;
cpo_match = (vim_strchr(p_cpo, CPO_MATCH) != NULL);
cpo_bsl = (vim_strchr(p_cpo, CPO_MATCHBSL) != NULL);
- /* Direction to search when initc is '/', '*' or '#' */
+ // Direction to search when initc is '/', '*' or '#'
if (flags & FM_BACKWARD)
dir = BACKWARD;
else if (flags & FM_FORWARD)
*/
if (!cpo_match)
{
- /* Are we before or at #if, #else etc.? */
+ // Are we before or at #if, #else etc.?
ptr = skipwhite(linep);
if (*ptr == '#' && pos.col <= (colnr_T)(ptr - linep))
{
hash_dir = 1;
}
- /* Are we on a comment? */
+ // Are we on a comment?
else if (linep[pos.col] == '/')
{
if (linep[pos.col + 1] == '*')
}
if (!findc)
{
- /* no brace in the line, maybe use " #if" then */
+ // no brace in the line, maybe use " #if" then
if (!cpo_match && *skipwhite(linep) == '#')
hash_dir = 1;
else
{
int col, bslcnt = 0;
- /* Set "match_escaped" if there are an odd number of
- * backslashes. */
+ // Set "match_escaped" if there are an odd number of
+ // backslashes.
for (col = pos.col; check_prevcol(linep, col, '\\', &col);)
bslcnt++;
match_escaped = (bslcnt & 1);
* Look for matching #if, #else, #elif, or #endif
*/
if (oap != NULL)
- oap->motion_type = MLINE; /* Linewise for this case only */
+ oap->motion_type = MLINE; // Linewise for this case only
if (initc != '#')
{
ptr = skipwhite(skipwhite(linep) + 1);
break;
pos.lnum += hash_dir;
linep = ml_get(pos.lnum);
- line_breakcheck(); /* check for CTRL-C typed */
+ line_breakcheck(); // check for CTRL-C typed
ptr = skipwhite(linep);
if (*ptr != '#')
continue;
}
#ifdef FEAT_RIGHTLEFT
- /* This is just guessing: when 'rightleft' is set, search for a matching
- * paren/brace in the other direction. */
+ // This is just guessing: when 'rightleft' is set, search for a matching
+ // paren/brace in the other direction.
if (curwin->w_p_rl && vim_strchr((char_u *)"()[]{}<>", initc) != NULL)
backwards = !backwards;
#endif
start_in_quotes = MAYBE;
CLEAR_POS(&match_pos);
- /* backward search: Check if this line contains a single-line comment */
+ // backward search: Check if this line contains a single-line comment
if ((backwards && comment_dir)
#ifdef FEAT_LISP
|| lisp
comment_col = check_linecomment(linep);
#ifdef FEAT_LISP
if (lisp && comment_col != MAXCOL && pos.col > (colnr_T)comment_col)
- lispcomm = TRUE; /* find match inside this comment */
+ lispcomm = TRUE; // find match inside this comment
#endif
while (!got_int)
{
if (backwards)
{
#ifdef FEAT_LISP
- /* char to match is inside of comment, don't search outside */
+ // char to match is inside of comment, don't search outside
if (lispcomm && pos.col < (colnr_T)comment_col)
break;
#endif
- if (pos.col == 0) /* at start of line, go to prev. one */
+ if (pos.col == 0) // at start of line, go to prev. one
{
- if (pos.lnum == 1) /* start of file */
+ if (pos.lnum == 1) // start of file
break;
--pos.lnum;
break;
linep = ml_get(pos.lnum);
- pos.col = (colnr_T)STRLEN(linep); /* pos.col on trailing NUL */
+ pos.col = (colnr_T)STRLEN(linep); // pos.col on trailing NUL
do_quotes = -1;
line_breakcheck();
- /* Check if this line contains a single-line comment */
+ // Check if this line contains a single-line comment
if (comment_dir
#ifdef FEAT_LISP
|| lisp
)
comment_col = check_linecomment(linep);
#ifdef FEAT_LISP
- /* skip comment */
+ // skip comment
if (lisp && comment_col != MAXCOL)
pos.col = comment_col;
#endif
pos.col -= (*mb_head_off)(linep, linep + pos.col);
}
}
- else /* forward search */
+ else // forward search
{
if (linep[pos.col] == NUL
- /* at end of line, go to next one */
+ // at end of line, go to next one
#ifdef FEAT_LISP
- /* don't search for match in comment */
+ // don't search for match in comment
|| (lisp && comment_col != MAXCOL
&& pos.col == (colnr_T)comment_col)
#endif
)
{
- if (pos.lnum == curbuf->b_ml.ml_line_count /* end of file */
+ if (pos.lnum == curbuf->b_ml.ml_line_count // end of file
#ifdef FEAT_LISP
- /* line is exhausted and comment with it,
- * don't search for match in code */
+ // line is exhausted and comment with it,
+ // don't search for match in code
|| lispcomm
#endif
)
do_quotes = -1;
line_breakcheck();
#ifdef FEAT_LISP
- if (lisp) /* find comment pos in new line */
+ if (lisp) // find comment pos in new line
comment_col = check_linecomment(linep);
#endif
}
if (pos.col == 0 && (flags & FM_BLOCKSTOP) &&
(linep[0] == '{' || linep[0] == '}'))
{
- if (linep[0] == findc && count == 0) /* match! */
+ if (linep[0] == findc && count == 0) // match!
return &pos;
- break; /* out of scope */
+ break; // out of scope
}
if (comment_dir)
{
- /* Note: comments do not nest, and we ignore quotes in them */
- /* TODO: ignore comment brackets inside strings */
+ // Note: comments do not nest, and we ignore quotes in them
+ // TODO: ignore comment brackets inside strings
if (comment_dir == FORWARD)
{
if (linep[pos.col] == '*' && linep[pos.col + 1] == '/')
return &pos;
}
}
- else /* Searching backwards */
+ else // Searching backwards
{
/*
* A comment may contain / * or / /, it may also start or end
&& linep[pos.col] == '"'
&& vim_strchr(linep + pos.col + 1, '(') != NULL)
{
- /* Possible start of raw string. Now that we have the
- * delimiter we can check if it ends before where we
- * started searching, or before the previously found
- * raw string start. */
+ // Possible start of raw string. Now that we have the
+ // delimiter we can check if it ends before where we
+ // started searching, or before the previously found
+ // raw string start.
if (!find_rawstring_end(linep, &pos,
count > 0 ? &match_pos : &curwin->w_cursor))
{
match_pos = pos;
match_pos.col--;
}
- linep = ml_get(pos.lnum); /* may have been released */
+ linep = ml_get(pos.lnum); // may have been released
}
}
else if ( linep[pos.col - 1] == '/'
if (*ptr == '\\' && ptr[1] != NUL)
++ptr;
}
- do_quotes &= 1; /* result is 1 with even number of quotes */
+ do_quotes &= 1; // result is 1 with even number of quotes
/*
* If we find an uneven count, check current line and previous
do_quotes = 1;
if (start_in_quotes == MAYBE)
{
- /* Do we need to use at_start here? */
+ // Do we need to use at_start here?
inquote = TRUE;
start_in_quotes = TRUE;
}
inquote = TRUE;
}
- /* ml_get() only keeps one line, need to get linep again */
+ // ml_get() only keeps one line, need to get linep again
linep = ml_get(pos.lnum);
}
}
switch (c)
{
case NUL:
- /* at end of line without trailing backslash, reset inquote */
+ // at end of line without trailing backslash, reset inquote
if (pos.col == 0 || linep[pos.col - 1] != '\\')
{
inquote = FALSE;
break;
case '"':
- /* a quote that is preceded with an odd number of backslashes is
- * ignored */
+ // a quote that is preceded with an odd number of backslashes is
+ // ignored
if (do_quotes)
{
int col;
}
}
}
- else if (linep[pos.col + 1]) /* forward search */
+ else if (linep[pos.col + 1]) // forward search
{
if (linep[pos.col + 1] == '\\' &&
linep[pos.col + 2] && linep[pos.col + 3] == '\'')
}
}
}
- /* FALLTHROUGH */
+ // FALLTHROUGH
default:
#ifdef FEAT_LISP
break;
#endif
- /* Check for match outside of quotes, and inside of
- * quotes when the start is also inside of quotes. */
+ // Check for match outside of quotes, and inside of
+ // quotes when the start is also inside of quotes.
if ((!inquote || start_in_quotes == TRUE)
&& (c == initc || c == findc))
{
for (col = pos.col; check_prevcol(linep, col, '\\', &col);)
bslcnt++;
}
- /* Only accept a match when 'M' is in 'cpo' or when escaping
- * is what we expect. */
+ // Only accept a match when 'M' is in 'cpo' or when escaping
+ // is what we expect.
if (cpo_bsl || (bslcnt & 1) == match_escaped)
{
if (c == initc)
pos = match_pos;
return &pos;
}
- return (pos_T *)NULL; /* never found it */
+ return (pos_T *)NULL; // never found it
}
/*
p = line;
#ifdef FEAT_LISP
- /* skip Lispish one-line comments */
+ // skip Lispish one-line comments
if (curbuf->b_p_lisp)
{
- if (vim_strchr(p, ';') != NULL) /* there may be comments */
+ if (vim_strchr(p, ';') != NULL) // there may be comments
{
- int in_str = FALSE; /* inside of string */
+ int in_str = FALSE; // inside of string
- p = line; /* scan from start */
+ p = line; // scan from start
while ((p = vim_strpbrk(p, (char_u *)"\";")) != NULL)
{
if (*p == '"')
{
if (in_str)
{
- if (*(p - 1) != '\\') /* skip escaped quote */
+ if (*(p - 1) != '\\') // skip escaped quote
in_str = FALSE;
}
else if (p == line || ((p - line) >= 2
- /* skip #\" form */
+ // skip #\" form
&& *(p - 1) != '\\' && *(p - 2) != '#'))
in_str = TRUE;
}
else if (!in_str && ((p - line) < 2
|| (*(p - 1) != '\\' && *(p - 2) != '#')))
- break; /* found! */
+ break; // found!
++p;
}
}
#endif
while ((p = vim_strchr(p, '/')) != NULL)
{
- /* accept a double /, unless it's preceded with * and followed by *,
- * because * / / * is an end and start of a C comment */
+ // accept a double /, unless it's preceded with * and followed by *,
+ // because * / / * is an end and start of a C comment
if (p[1] == '/' && (p == line || p[-1] != '*' || p[2] != '*'))
break;
++p;
*/
void
showmatch(
- int c) /* char to show match for */
+ int c) // char to show match for
{
pos_T *lpos, save_cursor;
pos_T mpos;
/*
* Only show match for chars in the 'matchpairs' option.
*/
- /* 'matchpairs' is "x:y,x:y" */
+ // 'matchpairs' is "x:y,x:y"
for (p = curbuf->b_p_mps; *p != NUL; ++p)
{
#ifdef FEAT_RIGHTLEFT
return;
}
- if ((lpos = findmatch(NULL, NUL)) == NULL) /* no match, so beep */
+ if ((lpos = findmatch(NULL, NUL)) == NULL) // no match, so beep
vim_beep(BO_MATCH);
else if (lpos->lnum >= curwin->w_topline && lpos->lnum < curwin->w_botline)
{
if (curwin->w_p_wrap || (vcol >= curwin->w_leftcol
&& vcol < curwin->w_leftcol + curwin->w_width))
{
- mpos = *lpos; /* save the pos, update_screen() may change it */
+ mpos = *lpos; // save the pos, update_screen() may change it
save_cursor = curwin->w_cursor;
save_so = *so;
save_siso = *siso;
- /* Handle "$" in 'cpo': If the ')' is typed on top of the "$",
- * stop displaying the "$". */
+ // Handle "$" in 'cpo': If the ')' is typed on top of the "$",
+ // stop displaying the "$".
if (dollar_vcol >= 0 && dollar_vcol == curwin->w_virtcol)
dollar_vcol = -1;
- ++curwin->w_virtcol; /* do display ')' just before "$" */
- update_screen(VALID); /* show the new char first */
+ ++curwin->w_virtcol; // do display ')' just before "$"
+ update_screen(VALID); // show the new char first
save_dollar_vcol = dollar_vcol;
#ifdef CURSOR_SHAPE
save_state = State;
State = SHOWMATCH;
- ui_cursor_shape(); /* may show different cursor shape */
+ ui_cursor_shape(); // may show different cursor shape
#endif
- curwin->w_cursor = mpos; /* move to matching char */
- *so = 0; /* don't use 'scrolloff' here */
- *siso = 0; /* don't use 'sidescrolloff' here */
+ curwin->w_cursor = mpos; // move to matching char
+ *so = 0; // don't use 'scrolloff' here
+ *siso = 0; // don't use 'sidescrolloff' here
showruler(FALSE);
setcursor();
- cursor_on(); /* make sure that the cursor is shown */
+ cursor_on(); // make sure that the cursor is shown
out_flush_cursor(TRUE, FALSE);
- /* Restore dollar_vcol(), because setcursor() may call curs_rows()
- * which resets it if the matching position is in a previous line
- * and has a higher column number. */
+ // Restore dollar_vcol(), because setcursor() may call curs_rows()
+ // which resets it if the matching position is in a previous line
+ // and has a higher column number.
dollar_vcol = save_dollar_vcol;
/*
ui_delay(p_mat * 100L + 8, TRUE);
else if (!char_avail())
ui_delay(p_mat * 100L + 9, FALSE);
- curwin->w_cursor = save_cursor; /* restore cursor position */
+ curwin->w_cursor = save_cursor; // restore cursor position
*so = save_so;
*siso = save_siso;
#ifdef CURSOR_SHAPE
State = save_state;
- ui_cursor_shape(); /* may show different cursor shape */
+ ui_cursor_shape(); // may show different cursor shape
#endif
}
}
int c;
int (*func)(pos_T *);
int startlnum;
- int noskip = FALSE; /* do not skip blanks */
+ int noskip = FALSE; // do not skip blanks
int cpo_J;
int found_dot;
decl(&pos);
}
- /* remember the line where the search started */
+ // remember the line where the search started
startlnum = pos.lnum;
cpo_J = vim_strchr(p_cpo, CPO_ENDOFSENT) != NULL;
- for (;;) /* find end of sentence */
+ for (;;) // find end of sentence
{
c = gchar_pos(&pos);
if (c == NUL || (pos.col == 0 && startPS(pos.lnum, NUL, FALSE)))
&& gchar_pos(&tpos) == ' ')))
{
pos = tpos;
- if (gchar_pos(&pos) == NUL) /* skip NUL at EOL */
+ if (gchar_pos(&pos) == NUL) // skip NUL at EOL
inc(&pos);
break;
}
}
}
found:
- /* skip white space */
+ // skip white space
while (!noskip && ((c = gchar_pos(&pos)) == ' ' || c == '\t'))
if (incl(&pos) == -1)
break;
*/
int
findpar(
- int *pincl, /* Return: TRUE if last char is to be included */
+ int *pincl, // Return: TRUE if last char is to be included
int dir,
long count,
int what,
int both)
{
linenr_T curr;
- int did_skip; /* TRUE after separating lines have been skipped */
- int first; /* TRUE on first line */
+ int did_skip; // TRUE after separating lines have been skipped
+ int first; // TRUE on first line
int posix = (vim_strchr(p_cpo, CPO_PARA) != NULL);
#ifdef FEAT_FOLDING
- linenr_T fold_first; /* first line of a closed fold */
- linenr_T fold_last; /* last line of a closed fold */
- int fold_skipped; /* TRUE if a closed fold was skipped this
- iteration */
+ linenr_T fold_first; // first line of a closed fold
+ linenr_T fold_last; // last line of a closed fold
+ int fold_skipped; // TRUE if a closed fold was skipped this
+ // iteration
#endif
curr = curwin->w_cursor.lnum;
did_skip = TRUE;
#ifdef FEAT_FOLDING
- /* skip folded lines */
+ // skip folded lines
fold_skipped = FALSE;
if (first && hasFolding(curr, &fold_first, &fold_last))
{
}
#endif
- /* POSIX has its own ideas of what a paragraph boundary is and it
- * doesn't match historical Vi: It also stops at a "{" in the
- * first column and at an empty line. */
+ // POSIX has its own ideas of what a paragraph boundary is and it
+ // doesn't match historical Vi: It also stops at a "{" in the
+ // first column and at an empty line.
if (!first && did_skip && (startPS(curr, what, both)
|| (posix && what == NUL && *ml_get(curr) == '{')))
break;
}
}
setpcmark();
- if (both && *ml_get(curr) == '}') /* include line with '}' */
+ if (both && *ml_get(curr) == '}') // include line with '}'
++curr;
curwin->w_cursor.lnum = curr;
if (curr == curbuf->b_ml.ml_line_count && what != '}')
{
char_u *line = ml_get(curr);
- /* Put the cursor on the last character in the last line and make the
- * motion inclusive. */
+ // Put the cursor on the last character in the last line and make the
+ // motion inclusive.
if ((curwin->w_cursor.col = (colnr_T)STRLEN(line)) != 0)
{
--curwin->w_cursor.col;
for (macro = opt; macro[0]; ++macro)
{
- /* Accept two characters in the option being equal to two characters
- * in the line. A space in the option matches with a space in the
- * line or the line having ended. */
+ // Accept two characters in the option being equal to two characters
+ // in the line. A space in the option matches with a space in the
+ // line or the line having ended.
if ( (macro[0] == s[0]
|| (macro[0] == ' '
&& (s[0] == NUL || s[0] == ' ')))
* 2 or higher - keyword characters (letters, digits and underscore)
*/
-static int cls_bigword; /* TRUE for "W", "B" or "E" */
+static int cls_bigword; // TRUE for "W", "B" or "E"
/*
* cls() - returns the class of character at curwin->w_cursor
return 0;
if (enc_dbcs != 0 && c > 0xFF)
{
- /* If cls_bigword, report multi-byte chars as class 1. */
+ // If cls_bigword, report multi-byte chars as class 1.
if (enc_dbcs == DBCS_KOR && cls_bigword)
return 1;
- /* process code leading/trailing bytes */
+ // process code leading/trailing bytes
return dbcs_class(((unsigned)c >> 8), (c & 0xFF));
}
if (enc_utf8)
return c;
}
- /* If cls_bigword is TRUE, report all non-blanks as class 1. */
+ // If cls_bigword is TRUE, report all non-blanks as class 1.
if (cls_bigword)
return 1;
int
fwd_word(
long count,
- int bigword, /* "W", "E" or "B" */
+ int bigword, // "W", "E" or "B"
int eol)
{
- int sclass; /* starting class */
+ int sclass; // starting class
int i;
int last_line;
while (--count >= 0)
{
#ifdef FEAT_FOLDING
- /* When inside a range of folded lines, move to the last char of the
- * last line. */
+ // When inside a range of folded lines, move to the last char of the
+ // last line.
if (hasFolding(curwin->w_cursor.lnum, NULL, &curwin->w_cursor.lnum))
coladvance((colnr_T)MAXCOL);
#endif
*/
last_line = (curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count);
i = inc_cursor();
- if (i == -1 || (i >= 1 && last_line)) /* started at last char in file */
+ if (i == -1 || (i >= 1 && last_line)) // started at last char in file
return FAIL;
- if (i >= 1 && eol && count == 0) /* started at last char in line */
+ if (i >= 1 && eol && count == 0) // started at last char in line
return OK;
/*
int
bck_word(long count, int bigword, int stop)
{
- int sclass; /* starting class */
+ int sclass; // starting class
curwin->w_cursor.coladd = 0;
cls_bigword = bigword;
while (--count >= 0)
{
#ifdef FEAT_FOLDING
- /* When inside a range of folded lines, move to the first char of the
- * first line. */
+ // When inside a range of folded lines, move to the first char of the
+ // first line.
if (hasFolding(curwin->w_cursor.lnum, &curwin->w_cursor.lnum, NULL))
curwin->w_cursor.col = 0;
#endif
sclass = cls();
- if (dec_cursor() == -1) /* started at start of file */
+ if (dec_cursor() == -1) // started at start of file
return FAIL;
if (!stop || sclass == cls() || sclass == 0)
if (curwin->w_cursor.col == 0
&& LINEEMPTY(curwin->w_cursor.lnum))
goto finished;
- if (dec_cursor() == -1) /* hit start of file, stop here */
+ if (dec_cursor() == -1) // hit start of file, stop here
return OK;
}
return OK;
}
- inc_cursor(); /* overshot - forward one */
+ inc_cursor(); // overshot - forward one
finished:
stop = FALSE;
}
int stop,
int empty)
{
- int sclass; /* starting class */
+ int sclass; // starting class
curwin->w_cursor.coladd = 0;
cls_bigword = bigword;
while (--count >= 0)
{
#ifdef FEAT_FOLDING
- /* When inside a range of folded lines, move to the last char of the
- * last line. */
+ // When inside a range of folded lines, move to the last char of the
+ // last line.
if (hasFolding(curwin->w_cursor.lnum, NULL, &curwin->w_cursor.lnum))
coladvance((colnr_T)MAXCOL);
#endif
if (empty && curwin->w_cursor.col == 0
&& LINEEMPTY(curwin->w_cursor.lnum))
goto finished;
- if (inc_cursor() == -1) /* hit end of file, stop here */
+ if (inc_cursor() == -1) // hit end of file, stop here
return FAIL;
}
if (skip_chars(cls(), FORWARD))
return FAIL;
}
- dec_cursor(); /* overshot - one char backward */
+ dec_cursor(); // overshot - one char backward
finished:
- stop = FALSE; /* we move only one word less */
+ stop = FALSE; // we move only one word less
}
return OK;
}
int
bckend_word(
long count,
- int bigword, /* TRUE for "B" */
- int eol) /* TRUE: stop at end of line. */
+ int bigword, // TRUE for "B"
+ int eol) // TRUE: stop at end of line.
{
- int sclass; /* starting class */
+ int sclass; // starting class
int i;
curwin->w_cursor.coladd = 0;
static void
back_in_line(void)
{
- int sclass; /* starting class */
+ int sclass; // starting class
sclass = cls();
for (;;)
{
- if (curwin->w_cursor.col == 0) /* stop at start of line */
+ if (curwin->w_cursor.col == 0) // stop at start of line
break;
dec_cursor();
- if (cls() != sclass) /* stop at start of word */
+ if (cls() != sclass) // stop at start of word
{
inc_cursor();
break;
static void
findsent_forward(
long count,
- int at_start_sent) /* cursor is at start of sentence */
+ int at_start_sent) // cursor is at start of sentence
{
while (count--)
{
current_word(
oparg_T *oap,
long count,
- int include, /* TRUE: include word and white space */
- int bigword) /* FALSE == word, TRUE == WORD */
+ int include, // TRUE: include word and white space
+ int bigword) // FALSE == word, TRUE == WORD
{
pos_T start_pos;
pos_T pos;
cls_bigword = bigword;
CLEAR_POS(&start_pos);
- /* Correct cursor when 'selection' is exclusive */
+ // Correct cursor when 'selection' is exclusive
if (VIsual_active && *p_sel == 'e' && LT_POS(VIsual, curwin->w_cursor))
dec_cursor();
if (VIsual_active)
{
- /* should do something when inclusive == FALSE ! */
+ // should do something when inclusive == FALSE !
VIsual = start_pos;
- redraw_curbuf_later(INVERTED); /* update the inversion */
+ redraw_curbuf_later(INVERTED); // update the inversion
}
else
{
* (cursor is at start of next line).
* But don't delete white space at start of line (indent).
*/
- pos = curwin->w_cursor; /* save cursor position */
+ pos = curwin->w_cursor; // save cursor position
curwin->w_cursor = start_pos;
if (oneleft() == OK)
{
oap->start = curwin->w_cursor;
}
}
- curwin->w_cursor = pos; /* put cursor back at end */
+ curwin->w_cursor = pos; // put cursor back at end
}
if (VIsual_active)
if (VIsual_mode == 'V')
{
VIsual_mode = 'v';
- redraw_cmdline = TRUE; /* show mode later */
+ redraw_cmdline = TRUE; // show mode later
}
}
else
start_pos = curwin->w_cursor;
pos = start_pos;
- findsent(FORWARD, 1L); /* Find start of next sentence. */
+ findsent(FORWARD, 1L); // Find start of next sentence.
/*
* When the Visual area is bigger than one character: Extend it.
{
findsent(BACKWARD, 1L);
if (EQUAL_POS(curwin->w_cursor, start_pos))
- at_start_sent = TRUE; /* exactly at start of sentence */
+ at_start_sent = TRUE; // exactly at start of sentence
else
- /* inside a sentence, go to its end (start of next) */
+ // inside a sentence, go to its end (start of next)
findsent(FORWARD, 1L);
}
- if (include) /* "as" gets twice as much as "is" */
+ if (include) // "as" gets twice as much as "is"
count *= 2;
while (count--)
{
*/
incl(&pos);
at_start_sent = TRUE;
- /* not just before a sentence */
+ // not just before a sentence
if (!EQUAL_POS(pos, curwin->w_cursor))
{
at_start_sent = FALSE;
}
incl(&pos);
}
- if (at_start_sent) /* in the sentence */
+ if (at_start_sent) // in the sentence
findsent(BACKWARD, 1L);
- else /* in/before white before a sentence */
+ else // in/before white before a sentence
curwin->w_cursor = start_pos;
}
- if (include) /* "as" gets twice as much as "is" */
+ if (include) // "as" gets twice as much as "is"
count *= 2;
findsent_forward(count, at_start_sent);
if (*p_sel == 'e')
* If the cursor started on a blank, check if it is just before the start
* of the next sentence.
*/
- while (c = gchar_pos(&pos), VIM_ISWHITE(c)) /* VIM_ISWHITE() is a macro */
+ while (c = gchar_pos(&pos), VIM_ISWHITE(c)) // VIM_ISWHITE() is a macro
incl(&pos);
if (EQUAL_POS(pos, curwin->w_cursor))
{
start_blank = TRUE;
- find_first_blank(&start_pos); /* go back to first blank */
+ find_first_blank(&start_pos); // go back to first blank
}
else
{
if (start_blank)
{
find_first_blank(&curwin->w_cursor);
- c = gchar_pos(&curwin->w_cursor); /* VIM_ISWHITE() is a macro */
+ c = gchar_pos(&curwin->w_cursor); // VIM_ISWHITE() is a macro
if (VIM_ISWHITE(c))
decl(&curwin->w_cursor);
}
if (VIsual_active)
{
- /* Avoid getting stuck with "is" on a single space before a sentence. */
+ // Avoid getting stuck with "is" on a single space before a sentence.
if (EQUAL_POS(start_pos, curwin->w_cursor))
goto extend;
if (*p_sel == 'e')
++curwin->w_cursor.col;
VIsual = start_pos;
VIsual_mode = 'v';
- redraw_cmdline = TRUE; /* show mode later */
- redraw_curbuf_later(INVERTED); /* update the inversion */
+ redraw_cmdline = TRUE; // show mode later
+ redraw_curbuf_later(INVERTED); // update the inversion
}
else
{
- /* include a newline after the sentence, if there is one */
+ // include a newline after the sentence, if there is one
if (incl(&curwin->w_cursor) == -1)
oap->inclusive = TRUE;
else
current_block(
oparg_T *oap,
long count,
- int include, /* TRUE == include white space */
- int what, /* '(', '{', etc. */
- int other) /* ')', '}', etc. */
+ int include, // TRUE == include white space
+ int what, // '(', '{', etc.
+ int other) // ')', '}', etc.
{
pos_T old_pos;
pos_T *pos = NULL;
pos_T *end_pos;
pos_T old_start, old_end;
char_u *save_cpo;
- int sol = FALSE; /* '{' at start of line */
+ int sol = FALSE; // '{' at start of line
old_pos = curwin->w_cursor;
- old_end = curwin->w_cursor; /* remember where we started */
+ old_end = curwin->w_cursor; // remember where we started
old_start = old_end;
/*
if (!VIsual_active || EQUAL_POS(VIsual, curwin->w_cursor))
{
setpcmark();
- if (what == '{') /* ignore indent */
+ if (what == '{') // ignore indent
while (inindent(1))
if (inc_cursor() != 0)
break;
if (gchar_cursor() == what)
- /* cursor on '(' or '{', move cursor just after it */
+ // cursor on '(' or '{', move cursor just after it
++curwin->w_cursor.col;
}
else if (LT_POS(VIsual, curwin->w_cursor))
{
old_start = VIsual;
- curwin->w_cursor = VIsual; /* cursor at low end of Visual */
+ curwin->w_cursor = VIsual; // cursor at low end of Visual
}
else
old_end = VIsual;
if ((pos = findmatch(NULL, what)) == NULL)
break;
curwin->w_cursor = *pos;
- start_pos = *pos; /* the findmatch for end_pos will overwrite *pos */
+ start_pos = *pos; // the findmatch for end_pos will overwrite *pos
}
p_cpo = save_cpo;
if (*p_sel == 'e')
inc(&curwin->w_cursor);
if (sol && gchar_cursor() != NUL)
- inc(&curwin->w_cursor); /* include the line break */
+ inc(&curwin->w_cursor); // include the line break
VIsual = start_pos;
VIsual_mode = 'v';
- redraw_curbuf_later(INVERTED); /* update the inversion */
+ redraw_curbuf_later(INVERTED); // update the inversion
showmode();
}
else
if (sol)
incl(&curwin->w_cursor);
else if (LTOREQ_POS(start_pos, curwin->w_cursor))
- /* Include the character under the cursor. */
+ // Include the character under the cursor.
oap->inclusive = TRUE;
else
- /* End is before the start (no text in between <>, [], etc.): don't
- * operate on any text. */
+ // End is before the start (no text in between <>, [], etc.): don't
+ // operate on any text.
curwin->w_cursor = start_pos;
}
{
char_u *lp = NULL;
- /* We search forward until the cursor, because searching backwards is
- * very slow for DBCS encodings. */
+ // We search forward until the cursor, because searching backwards is
+ // very slow for DBCS encodings.
for (p = line; p < line + curwin->w_cursor.col; MB_PTR_ADV(p))
if (*p == '>' || *p == '<')
{
lc = *p;
lp = p;
}
- if (*p != '<') /* check for '<' under cursor */
+ if (*p != '<') // check for '<' under cursor
{
if (lc != '<')
return FALSE;
{
for (p = line + curwin->w_cursor.col; p > line; )
{
- if (*p == '<') /* find '<' under/before cursor */
+ if (*p == '<') // find '<' under/before cursor
break;
MB_PTR_BACK(line, p);
- if (*p == '>') /* find '>' before cursor */
+ if (*p == '>') // find '>' before cursor
break;
}
if (*p != '<')
MB_PTR_ADV(p);
if (end_tag)
- /* check that there is a '/' after the '<' */
+ // check that there is a '/' after the '<'
return *p == '/';
- /* check that there is no '/' after the '<' */
+ // check that there is no '/' after the '<'
if (*p == '/')
return FALSE;
- /* check that the matching '>' is not preceded by '/' */
+ // check that the matching '>' is not preceded by '/'
for (;;)
{
if (inc(&pos) < 0)
current_tagblock(
oparg_T *oap,
long count_arg,
- int include) /* TRUE == include white space */
+ int include) // TRUE == include white space
{
long count = count_arg;
long n;
p_ws = FALSE;
old_pos = curwin->w_cursor;
- old_end = curwin->w_cursor; /* remember where we started */
+ old_end = curwin->w_cursor; // remember where we started
old_start = old_end;
if (!VIsual_active || *p_sel == 'e')
- decl(&old_end); /* old_end is inclusive */
+ decl(&old_end); // old_end is inclusive
/*
* If we start on "<aaa>" select that block.
{
setpcmark();
- /* ignore indent */
+ // ignore indent
while (inindent(1))
if (inc_cursor() != 0)
break;
if (in_html_tag(FALSE))
{
- /* cursor on start tag, move to its '>' */
+ // cursor on start tag, move to its '>'
while (*ml_get_cursor() != '>')
if (inc_cursor() < 0)
break;
}
else if (in_html_tag(TRUE))
{
- /* cursor on end tag, move to just before it */
+ // cursor on end tag, move to just before it
while (*ml_get_cursor() != '<')
if (dec_cursor() < 0)
break;
else if (LT_POS(VIsual, curwin->w_cursor))
{
old_start = VIsual;
- curwin->w_cursor = VIsual; /* cursor at low end of Visual */
+ curwin->w_cursor = VIsual; // cursor at low end of Visual
}
else
old_end = VIsual;
if (r < 1 || LT_POS(curwin->w_cursor, old_end))
{
- /* Can't find other end or it's before the previous end. Could be a
- * HTML tag that doesn't have a matching end. Search backwards for
- * another starting tag. */
+ // Can't find other end or it's before the previous end. Could be a
+ // HTML tag that doesn't have a matching end. Search backwards for
+ // another starting tag.
count = 1;
curwin->w_cursor = start_pos;
goto again;
if (do_include)
{
- /* Include up to the '>'. */
+ // Include up to the '>'.
while (*ml_get_cursor() != '>')
if (inc_cursor() < 0)
break;
{
char_u *c = ml_get_cursor();
- /* Exclude the '<' of the end tag.
- * If the closing tag is on new line, do not decrement cursor, but
- * make operation exclusive, so that the linefeed will be selected */
+ // Exclude the '<' of the end tag.
+ // If the closing tag is on new line, do not decrement cursor, but
+ // make operation exclusive, so that the linefeed will be selected
if (*c == '<' && !VIsual_active && curwin->w_cursor.col == 0)
- /* do not decrement cursor */
+ // do not decrement cursor
is_inclusive = FALSE;
else if (*c == '<')
dec_cursor();
if (!do_include)
{
- /* Exclude the start tag. */
+ // Exclude the start tag.
curwin->w_cursor = start_pos;
while (inc_cursor() >= 0)
if (*ml_get_cursor() == '>')
if (VIsual_active)
{
- /* If the end is before the start there is no text between tags, select
- * the char under the cursor. */
+ // If the end is before the start there is no text between tags, select
+ // the char under the cursor.
if (LT_POS(end_pos, start_pos))
curwin->w_cursor = start_pos;
else if (*p_sel == 'e')
inc_cursor();
VIsual = start_pos;
VIsual_mode = 'v';
- redraw_curbuf_later(INVERTED); /* update the inversion */
+ redraw_curbuf_later(INVERTED); // update the inversion
showmode();
}
else
oap->motion_type = MCHAR;
if (LT_POS(end_pos, start_pos))
{
- /* End is before the start: there is no text between tags; operate
- * on an empty area. */
+ // End is before the start: there is no text between tags; operate
+ // on an empty area.
curwin->w_cursor = start_pos;
oap->inclusive = FALSE;
}
current_par(
oparg_T *oap,
long count,
- int include, /* TRUE == include white space */
- int type) /* 'p' for paragraph, 'S' for section */
+ int include, // TRUE == include white space
+ int type) // 'p' for paragraph, 'S' for section
{
linenr_T start_lnum;
linenr_T end_lnum;
int t;
int i;
- if (type == 'S') /* not implemented yet */
+ if (type == 'S') // not implemented yet
return FAIL;
start_lnum = curwin->w_cursor.lnum;
white_in_front = linewhite(start_lnum);
while (start_lnum > 1)
{
- if (white_in_front) /* stop at first white line */
+ if (white_in_front) // stop at first white line
{
if (!linewhite(start_lnum - 1))
break;
}
- else /* stop at first non-white line of start of paragraph */
+ else // stop at first non-white line of start of paragraph
{
if (linewhite(start_lnum - 1) || startPS(start_lnum, 0, 0))
break;
if (VIsual_active)
{
- /* Problem: when doing "Vipipip" nothing happens in a single white
- * line, we get stuck there. Trap this here. */
+ // Problem: when doing "Vipipip" nothing happens in a single white
+ // line, we get stuck there. Trap this here.
if (VIsual_mode == 'V' && start_lnum == curwin->w_cursor.lnum)
goto extend;
if (VIsual.lnum != start_lnum)
VIsual.col = 0;
}
VIsual_mode = 'V';
- redraw_curbuf_later(INVERTED); /* update the inversion */
+ redraw_curbuf_later(INVERTED); // update the inversion
showmode();
}
else
char_u *line,
int col,
int quotechar,
- char_u *escape) /* escape characters, can be NULL */
+ char_u *escape) // escape characters, can be NULL
{
int c;
char_u *line,
int col_start,
int quotechar,
- char_u *escape) /* escape characters, can be NULL */
+ char_u *escape) // escape characters, can be NULL
{
int n;
line[col_start - n - 1]) != NULL)
++n;
if (n & 1)
- col_start -= n; /* uneven number of escape chars, skip it */
+ col_start -= n; // uneven number of escape chars, skip it
else if (line[col_start] == quotechar)
break;
}
// The cursor then is moved forward after adjusting the area.
if (VIsual_active)
{
- /* this only works within one line */
+ // this only works within one line
if (VIsual.lnum != curwin->w_cursor.lnum)
return FALSE;
if (!vis_empty)
{
- /* Check if the existing selection exactly spans the text inside
- * quotes. */
+ // Check if the existing selection exactly spans the text inside
+ // quotes.
if (vis_bef_curs)
{
inside_quotes = VIsual.col > 0
col_end = VIsual.col;
}
- /* Find out if we have a quote in the selection. */
+ // Find out if we have a quote in the selection.
while (i <= col_end)
if (line[i++] == quotechar)
{
if (!vis_empty && line[col_start] == quotechar)
{
- /* Already selecting something and on a quote character. Find the
- * next quoted string. */
+ // Already selecting something and on a quote character. Find the
+ // next quoted string.
if (vis_bef_curs)
{
- /* Assume we are on a closing quote: move to after the next
- * opening quote. */
+ // Assume we are on a closing quote: move to after the next
+ // opening quote.
col_start = find_next_quote(line, col_start + 1, quotechar, NULL);
if (col_start < 0)
goto abort_search;
curbuf->b_p_qe);
if (col_end < 0)
{
- /* We were on a starting quote perhaps? */
+ // We were on a starting quote perhaps?
col_end = col_start;
col_start = curwin->w_cursor.col;
}
curbuf->b_p_qe);
if (line[col_start] != quotechar)
{
- /* We were on an ending quote perhaps? */
+ // We were on an ending quote perhaps?
col_start = col_end;
col_end = curwin->w_cursor.col;
}
first_col = find_prev_quote(line, col_start, quotechar, NULL);
}
- /* The cursor is on a quote, we don't know if it's the opening or
- * closing quote. Search from the start of the line to find out.
- * Also do this when there is a Visual area, a' may leave the cursor
- * in between two strings. */
+ // The cursor is on a quote, we don't know if it's the opening or
+ // closing quote. Search from the start of the line to find out.
+ // Also do this when there is a Visual area, a' may leave the cursor
+ // in between two strings.
col_start = 0;
for (;;)
{
- /* Find open quote character. */
+ // Find open quote character.
col_start = find_next_quote(line, col_start, quotechar, NULL);
if (col_start < 0 || col_start > first_col)
goto abort_search;
- /* Find close quote character. */
+ // Find close quote character.
col_end = find_next_quote(line, col_start + 1, quotechar,
curbuf->b_p_qe);
if (col_end < 0)
goto abort_search;
- /* If is cursor between start and end quote character, it is
- * target text object. */
+ // If is cursor between start and end quote character, it is
+ // target text object.
if (col_start <= first_col && first_col <= col_end)
break;
col_start = col_end + 1;
}
else
{
- /* Search backward for a starting quote. */
+ // Search backward for a starting quote.
col_start = find_prev_quote(line, col_start, quotechar, curbuf->b_p_qe);
if (line[col_start] != quotechar)
{
- /* No quote before the cursor, look after the cursor. */
+ // No quote before the cursor, look after the cursor.
col_start = find_next_quote(line, col_start, quotechar, NULL);
if (col_start < 0)
goto abort_search;
}
- /* Find close quote character. */
+ // Find close quote character.
col_end = find_next_quote(line, col_start + 1, quotechar,
curbuf->b_p_qe);
if (col_end < 0)
goto abort_search;
}
- /* When "include" is TRUE, include spaces after closing quote or before
- * the starting quote. */
+ // When "include" is TRUE, include spaces after closing quote or before
+ // the starting quote.
if (include)
{
if (VIM_ISWHITE(line[col_end + 1]))
--col_start;
}
- /* Set start position. After vi" another i" must include the ".
- * For v2i" include the quotes. */
+ // Set start position. After vi" another i" must include the ".
+ // For v2i" include the quotes.
if (!include && count < 2 && (vis_empty || !inside_quotes))
++col_start;
curwin->w_cursor.col = col_start;
if (VIsual_active)
{
- /* Set the start of the Visual area when the Visual area was empty, we
- * were just inside quotes or the Visual area didn't start at a quote
- * and didn't include a quote.
- */
+ // Set the start of the Visual area when the Visual area was empty, we
+ // were just inside quotes or the Visual area didn't start at a quote
+ // and didn't include a quote.
if (vis_empty
|| (vis_bef_curs
&& !selected_quote
oap->motion_type = MCHAR;
}
- /* Set end position. */
+ // Set end position.
curwin->w_cursor.col = col_end;
- if ((include || count > 1 /* After vi" another i" must include the ". */
+ if ((include || count > 1 // After vi" another i" must include the ".
|| (!vis_empty && inside_quotes)
) && inc_cursor() == 2)
inclusive = TRUE;
}
else
{
- /* Cursor is at start of Visual area. Set the end of the Visual
- * area when it was just inside quotes or it didn't end at a
- * quote. */
+ // Cursor is at start of Visual area. Set the end of the Visual
+ // area when it was just inside quotes or it didn't end at a
+ // quote.
if (inside_quotes
|| (!selected_quote
&& line[VIsual.col] != quotechar
if (VIsual_mode == 'V')
{
VIsual_mode = 'v';
- redraw_cmdline = TRUE; /* show mode later */
+ redraw_cmdline = TRUE; // show mode later
}
}
else
{
- /* Set inclusive and other oap's flags. */
+ // Set inclusive and other oap's flags.
oap->inclusive = inclusive;
}
return FALSE;
}
-#endif /* FEAT_TEXTOBJ */
+#endif // FEAT_TEXTOBJ
/*
* Check if the pattern is zero-width.
pos_T save_VIsual = VIsual;
int zero_width;
- /* Correct cursor when 'selection' is exclusive */
+ // Correct cursor when 'selection' is exclusive
if (VIsual_active && *p_sel == 'e' && LT_POS(VIsual, curwin->w_cursor))
dec_cursor();
decl(&pos);
}
- /* Is the pattern is zero-width?, this time, don't care about the direction
- */
+ // Is the pattern is zero-width?, this time, don't care about the direction
zero_width = is_zero_width(spats[last_idx].pat, TRUE, &curwin->w_cursor,
FORWARD);
if (zero_width == -1)
- return FAIL; /* pattern not found */
+ return FAIL; // pattern not found
/*
* The trick is to first search backwards and then search forward again,
p_ws = old_p_ws;
- /* First search may fail, but then start searching from the
- * beginning of the file (cursor might be on the search match)
- * except when Visual mode is active, so that extending the visual
- * selection works. */
- if (i == 1 && !result) /* not found, abort */
+ // First search may fail, but then start searching from the
+ // beginning of the file (cursor might be on the search match)
+ // except when Visual mode is active, so that extending the visual
+ // selection works.
+ if (i == 1 && !result) // not found, abort
{
curwin->w_cursor = orig_pos;
if (VIsual_active)
{
if (forward)
{
- /* try again from start of buffer */
+ // try again from start of buffer
CLEAR_POS(&pos);
}
else
{
- /* try again from end of buffer */
- /* searching backwards, so set pos to last line and col */
+ // try again from end of buffer
+ // searching backwards, so set pos to last line and col
pos.lnum = curwin->w_buffer->b_ml.ml_line_count;
pos.col = (colnr_T)STRLEN(
ml_get(curwin->w_buffer->b_ml.ml_line_count));
if (*p_sel == 'e')
{
- /* Correction for exclusive selection depends on the direction. */
+ // Correction for exclusive selection depends on the direction.
if (forward && LTOREQ_POS(VIsual, curwin->w_cursor))
inc_cursor();
else if (!forward && LTOREQ_POS(curwin->w_cursor, VIsual))
may_start_select('c');
setmouse();
#ifdef FEAT_CLIPBOARD
- /* Make sure the clipboard gets updated. Needed because start and
- * end are still the same, and the selection needs to be owned */
+ // Make sure the clipboard gets updated. Needed because start and
+ // end are still the same, and the selection needs to be owned
clip_star.vmode = NUL;
#endif
redraw_curbuf_later(INVERTED);
*/
void
find_pattern_in_path(
- char_u *ptr, /* pointer to search pattern */
- int dir UNUSED, /* direction of expansion */
- int len, /* length of search pattern */
- int whole, /* match whole words only */
- int skip_comments, /* don't match inside comments */
- int type, /* Type of search; are we looking for a type?
- a macro? */
+ char_u *ptr, // pointer to search pattern
+ int dir UNUSED, // direction of expansion
+ int len, // length of search pattern
+ int whole, // match whole words only
+ int skip_comments, // don't match inside comments
+ int type, // Type of search; are we looking for a type?
+ // a macro?
long count,
- int action, /* What to do when we find it */
- linenr_T start_lnum, /* first line to start searching */
- linenr_T end_lnum) /* last line for searching */
+ int action, // What to do when we find it
+ linenr_T start_lnum, // first line to start searching
+ linenr_T end_lnum) // last line for searching
{
- SearchedFile *files; /* Stack of included files */
- SearchedFile *bigger; /* When we need more space */
+ SearchedFile *files; // Stack of included files
+ SearchedFile *bigger; // When we need more space
int max_path_depth = 50;
long match_count = 1;
char_u *prev_fname = NULL;
linenr_T lnum;
int depth;
- int depth_displayed; /* For type==CHECK_PATH */
+ int depth_displayed; // For type==CHECK_PATH
int old_files;
int already_searched;
char_u *file_line;
return;
if (type != CHECK_PATH && type != FIND_DEFINE
- /* when CONT_SOL is set compare "ptr" with the beginning of the line
- * is faster than quote_meta/regcomp/regexec "ptr" -- Acevedo */
+ // when CONT_SOL is set compare "ptr" with the beginning of the line
+ // is faster than quote_meta/regcomp/regexec "ptr" -- Acevedo
&& !(compl_cont_status & CONT_SOL))
{
pat = alloc(len + 5);
if (pat == NULL)
goto fpip_end;
sprintf((char *)pat, whole ? "\\<%.*s\\>" : "%.*s", len, ptr);
- /* ignore case according to p_ic, p_scs and pat */
+ // ignore case according to p_ic, p_scs and pat
regmatch.rm_ic = ignorecase(pat);
regmatch.regprog = vim_regcomp(pat, p_magic ? RE_MAGIC : 0);
vim_free(pat);
incl_regmatch.regprog = vim_regcomp(inc_opt, p_magic ? RE_MAGIC : 0);
if (incl_regmatch.regprog == NULL)
goto fpip_end;
- incl_regmatch.rm_ic = FALSE; /* don't ignore case in incl. pat. */
+ incl_regmatch.rm_ic = FALSE; // don't ignore case in incl. pat.
}
if (type == FIND_DEFINE && (*curbuf->b_p_def != NUL || *p_def != NUL))
{
? p_def : curbuf->b_p_def, p_magic ? RE_MAGIC : 0);
if (def_regmatch.regprog == NULL)
goto fpip_end;
- def_regmatch.rm_ic = FALSE; /* don't ignore case in define pat. */
+ def_regmatch.rm_ic = FALSE; // don't ignore case in define pat.
}
files = lalloc_clear(max_path_depth * sizeof(SearchedFile), TRUE);
if (files == NULL)
lnum = start_lnum;
if (end_lnum > curbuf->b_ml.ml_line_count)
end_lnum = curbuf->b_ml.ml_line_count;
- if (lnum > end_lnum) /* do at least one line */
+ if (lnum > end_lnum) // do at least one line
lnum = end_lnum;
line = ml_get(lnum);
? curbuf->b_ffname : curr_fname;
if (inc_opt != NULL && strstr((char *)inc_opt, "\\zs") != NULL)
- /* Use text from '\zs' to '\ze' (or end) of 'include'. */
+ // Use text from '\zs' to '\ze' (or end) of 'include'.
new_fname = find_file_name_in_path(incl_regmatch.startp[0],
(int)(incl_regmatch.endp[0] - incl_regmatch.startp[0]),
FNAME_EXP|FNAME_INCL|FNAME_REL, 1L, p_fname);
else
- /* Use text after match with 'include'. */
+ // Use text after match with 'include'.
new_fname = file_name_in_line(incl_regmatch.endp[0], 0,
FNAME_EXP|FNAME_INCL|FNAME_REL, 1L, p_fname, NULL);
already_searched = FALSE;
if (new_fname != NULL)
{
- /* Check whether we have already searched in this file */
+ // Check whether we have already searched in this file
for (i = 0;; i++)
{
if (i == depth + 1)
if (type != CHECK_PATH &&
action == ACTION_SHOW_ALL && files[i].matched)
{
- msg_putchar('\n'); /* cursor below last one */
- if (!got_int) /* don't display if 'q'
- typed at "--more--"
- message */
+ msg_putchar('\n'); // cursor below last one
+ if (!got_int) // don't display if 'q'
+ // typed at "--more--"
+ // message
{
msg_home_replace_hl(new_fname);
msg_puts(_(" (includes previously listed match)"));
|| (new_fname == NULL && !already_searched)))
{
if (did_show)
- msg_putchar('\n'); /* cursor below last one */
+ msg_putchar('\n'); // cursor below last one
else
{
- gotocmdline(TRUE); /* cursor at status line */
+ gotocmdline(TRUE); // cursor at status line
msg_puts_title(_("--- Included files "));
if (action != ACTION_SHOW_ALL)
msg_puts_title(_("not found "));
msg_home_replace(files[depth_displayed].name);
msg_puts(" -->\n");
}
- if (!got_int) /* don't display if 'q' typed
- for "--more--" message */
+ if (!got_int) // don't display if 'q' typed
+ // for "--more--" message
{
for (i = 0; i <= depth_displayed; i++)
msg_puts(" ");
if (new_fname != NULL)
{
- /* using "new_fname" is more reliable, e.g., when
- * 'includeexpr' is set. */
+ // using "new_fname" is more reliable, e.g., when
+ // 'includeexpr' is set.
msg_outtrans_attr(new_fname, HL_ATTR(HLF_D));
}
else
if (inc_opt != NULL
&& strstr((char *)inc_opt, "\\zs") != NULL)
{
- /* pattern contains \zs, use the match */
+ // pattern contains \zs, use the match
p = incl_regmatch.startp[0];
i = (int)(incl_regmatch.endp[0]
- incl_regmatch.startp[0]);
}
else
{
- /* find the file name after the end of the match */
+ // find the file name after the end of the match
for (p = incl_regmatch.endp[0];
*p && !vim_isfilec(*p); p++)
;
if (i == 0)
{
- /* Nothing found, use the rest of the line. */
+ // Nothing found, use the rest of the line.
p = incl_regmatch.endp[0];
i = (int)STRLEN(p);
}
- /* Avoid checking before the start of the line, can
- * happen if \zs appears in the regexp. */
+ // Avoid checking before the start of the line, can
+ // happen if \zs appears in the regexp.
else if (p > line)
{
if (p[-1] == '"' || p[-1] == '<')
msg_puts(_(" NOT FOUND"));
}
}
- out_flush(); /* output each line directly */
+ out_flush(); // output each line directly
}
if (new_fname != NULL)
{
- /* Push the new file onto the file stack */
+ // Push the new file onto the file stack
if (depth + 1 == old_files)
{
bigger = ALLOC_MULT(SearchedFile, max_path_depth * 2);
files[depth].matched = FALSE;
if (action == ACTION_EXPAND)
{
- msg_hist_off = TRUE; /* reset in msg_trunc_attr() */
+ msg_hist_off = TRUE; // reset in msg_trunc_attr()
vim_snprintf((char*)IObuff, IOSIZE,
_("Scanning included file: %s"),
(char *)new_fname);
{
if (define_matched || (compl_cont_status & CONT_SOL))
{
- /* compare the first "len" chars from "ptr" */
+ // compare the first "len" chars from "ptr"
startp = skipwhite(p);
if (p_ic)
matched = !MB_STRNICMP(startp, ptr, len);
&& (p[1] == '*' || p[1] == '/'))
{
matched = FALSE;
- /* After "//" all text is comment */
+ // After "//" all text is comment
if (p[1] == '/')
break;
++p;
}
else if (!matched && p[0] == '*' && p[1] == '/')
{
- /* Can find match after "* /". */
+ // Can find match after "* /".
matched = TRUE;
++p;
}
if ((compl_cont_status & CONT_ADDING) && i == compl_length)
{
- /* IOSIZE > compl_length, so the STRNCPY works */
+ // IOSIZE > compl_length, so the STRNCPY works
STRNCPY(IObuff, aux, i);
- /* Get the next line: when "depth" < 0 from the current
- * buffer, otherwise from the included file. Jump to
- * exit_matched when past the last line. */
+ // Get the next line: when "depth" < 0 from the current
+ // buffer, otherwise from the included file. Jump to
+ // exit_matched when past the last line.
if (depth < 0)
{
if (lnum >= end_lnum)
LSIZE, files[depth].fp))
goto exit_matched;
- /* we read a line, set "already" to check this "line" later
- * if depth >= 0 we'll increase files[depth].lnum far
- * bellow -- Acevedo */
+ // we read a line, set "already" to check this "line" later
+ // if depth >= 0 we'll increase files[depth].lnum far
+ // bellow -- Acevedo
already = aux = p = skipwhite(line);
p = find_word_start(p);
p = find_word_end(p);
{
if (IObuff[i-1] != ' ')
IObuff[i++] = ' ';
- /* IObuf =~ "\(\k\|\i\).* ", thus i >= 2*/
+ // IObuf =~ "\(\k\|\i\).* ", thus i >= 2
if (p_js
&& (IObuff[i-2] == '.'
|| (vim_strchr(p_cpo, CPO_JOINSP) == NULL
|| IObuff[i-2] == '!'))))
IObuff[i++] = ' ';
}
- /* copy as much as possible of the new word */
+ // copy as much as possible of the new word
if (p - aux >= IOSIZE - i)
p = aux + IOSIZE - i - 1;
STRNCPY(IObuff + i, aux, p - aux);
curr_fname == curbuf->b_fname ? NULL : curr_fname,
dir, cont_s_ipos);
if (add_r == OK)
- /* if dir was BACKWARD then honor it just once */
+ // if dir was BACKWARD then honor it just once
dir = FORWARD;
else if (add_r == FAIL)
break;
{
found = TRUE;
if (!did_show)
- gotocmdline(TRUE); /* cursor at status line */
+ gotocmdline(TRUE); // cursor at status line
if (curr_fname != prev_fname)
{
if (did_show)
- msg_putchar('\n'); /* cursor below last one */
- if (!got_int) /* don't display if 'q' typed
- at "--more--" message */
+ msg_putchar('\n'); // cursor below last one
+ if (!got_int) // don't display if 'q' typed
+ // at "--more--" message
msg_home_replace_hl(curr_fname);
prev_fname = curr_fname;
}
(depth == -1) ? &lnum : &files[depth].lnum,
match_count++);
- /* Set matched flag for this file and all the ones that
- * include it */
+ // Set matched flag for this file and all the ones that
+ // include it
for (i = 0; i <= depth; ++i)
files[i].matched = TRUE;
}
need_mouse_correct = TRUE;
#endif
#if defined(FEAT_QUICKFIX)
- /* ":psearch" uses the preview window */
+ // ":psearch" uses the preview window
if (g_do_tagpreview != 0)
{
curwin_save = curwin;
}
if (depth == -1)
{
- /* match in current file */
+ // match in current file
#if defined(FEAT_QUICKFIX)
if (g_do_tagpreview != 0)
{
if (!GETFILE_SUCCESS(getfile(
curwin_save->w_buffer->b_fnum, NULL,
NULL, TRUE, lnum, FALSE)))
- break; /* failed to jump to file */
+ break; // failed to jump to file
}
else
#endif
if (!GETFILE_SUCCESS(getfile(
0, files[depth].name, NULL, TRUE,
files[depth].lnum, FALSE)))
- break; /* failed to jump to file */
- /* autocommands may have changed the lnum, we don't
- * want that here */
+ break; // failed to jump to file
+ // autocommands may have changed the lnum, we don't
+ // want that here
curwin->w_cursor.lnum = files[depth].lnum;
}
}
if (g_do_tagpreview != 0
&& curwin != curwin_save && win_valid(curwin_save))
{
- /* Return cursor to where we were */
+ // Return cursor to where we were
validate_cursor();
redraw_later(VALID);
win_enter(curwin_save, TRUE);
}
exit_matched:
matched = FALSE;
- /* look for other matches in the rest of the line if we
- * are not at the end of it already */
+ // look for other matches in the rest of the line if we
+ // are not at the end of it already
if (def_regmatch.regprog == NULL
&& action == ACTION_EXPAND
&& !(compl_cont_status & CONT_SOL)
if (depth < depth_displayed)
depth_displayed = depth;
}
- if (depth >= 0) /* we could read the line */
+ if (depth >= 0) // we could read the line
{
files[depth].lnum++;
- /* Remove any CR and LF from the line. */
+ // Remove any CR and LF from the line.
i = (int)STRLEN(line);
if (i > 0 && line[i - 1] == '\n')
line[--i] = NUL;
}
already = NULL;
}
- /* End of big for (;;) loop. */
+ // End of big for (;;) loop.
- /* Close any files that are still open. */
+ // Close any files that are still open.
for (i = 0; i <= depth; i++)
{
fclose(files[i].fp);
char_u *p;
if (did_show)
- msg_putchar('\n'); /* cursor below last one */
+ msg_putchar('\n'); // cursor below last one
else if (!msg_silent)
- gotocmdline(TRUE); /* cursor at status line */
- if (got_int) /* 'q' typed at "--more--" message */
+ gotocmdline(TRUE); // cursor at status line
+ if (got_int) // 'q' typed at "--more--" message
return;
for (;;)
{
p = line + STRLEN(line) - 1;
if (fp != NULL)
{
- /* We used fgets(), so get rid of newline at end */
+ // We used fgets(), so get rid of newline at end
if (p >= line && *p == '\n')
--p;
if (p >= line && *p == '\r')
}
if (action == ACTION_SHOW_ALL)
{
- sprintf((char *)IObuff, "%3ld: ", count); /* show match nr */
+ sprintf((char *)IObuff, "%3ld: ", count); // show match nr
msg_puts((char *)IObuff);
- sprintf((char *)IObuff, "%4ld", *lnum); /* show line nr */
- /* Highlight line numbers */
+ sprintf((char *)IObuff, "%4ld", *lnum); // show line nr
+ // Highlight line numbers
msg_puts_attr((char *)IObuff, HL_ATTR(HLF_N));
msg_puts(" ");
}
msg_prt_line(line, FALSE);
- out_flush(); /* show one line at a time */
+ out_flush(); // show one line at a time
- /* Definition continues until line that doesn't end with '\' */
+ // Definition continues until line that doesn't end with '\'
if (got_int || type != FIND_DEFINE || p < line || *p != '\\')
break;
if (fp != NULL)
{
- if (vim_fgets(line, LSIZE, fp)) /* end of file */
+ if (vim_fgets(line, LSIZE, fp)) // end of file
break;
++*lnum;
}
PUT_UINT32(ctx->state[6], digest, 24);
PUT_UINT32(ctx->state[7], digest, 28);
}
-#endif /* FEAT_CRYPT || FEAT_PERSISTENT_UNDO */
+#endif // FEAT_CRYPT || FEAT_PERSISTENT_UNDO
#if defined(FEAT_CRYPT) || defined(PROTO)
/*
char_u *salt,
int salt_len)
{
- /* No passwd means don't encrypt */
+ // No passwd means don't encrypt
if (buf == NULL || *buf == NUL)
return (char_u *)"";
{
failures++;
output[sizeof(output) - 1] = '\0';
- /* printf("sha256_self_test %d failed %s\n", i, output); */
+ // printf("sha256_self_test %d failed %s\n", i, output);
}
}
return failures > 0 ? FAIL : OK;
# ifdef HAVE_GETTIMEOFDAY
struct timeval tv;
- /* Using usec makes it less predictable. */
+ // Using usec makes it less predictable.
gettimeofday(&tv, NULL);
return (unsigned int)(tv.tv_sec + tv.tv_usec);
# else
sha256_update(&ctx, (char_u *)random_data, sizeof(random_data));
sha256_finish(&ctx, sha256sum);
- /* put first block into header. */
+ // put first block into header.
for (i = 0; i < header_len; i++)
header[i] = sha256sum[i % sizeof(sha256sum)];
- /* put remaining block into salt. */
+ // put remaining block into salt.
if (salt != NULL)
for (i = 0; i < salt_len; i++)
salt[i] = sha256sum[(i + header_len) % sizeof(sha256sum)];
}
-#endif /* FEAT_CRYPT */
+#endif // FEAT_CRYPT
return count;
}
-# endif /* FEAT_SIGN_ICONS */
-# endif /* FEAT_NETBEANS_INTG */
+# endif // FEAT_SIGN_ICONS
+# endif // FEAT_NETBEANS_INTG
/*
* Delete signs in group 'group' in buffer "buf". If 'group' is '*', then
}
}
-#endif /* FEAT_SIGNS */
+#endif // FEAT_SIGNS
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 2394,
/**/
2393,
/**/
projects / vim / commitdiff