diff options
Diffstat (limited to 'src/nvim/search.c')
| -rw-r--r-- | src/nvim/search.c | 956 |
1 files changed, 436 insertions, 520 deletions
diff --git a/src/nvim/search.c b/src/nvim/search.c index e995081df8..871d2f9a0a 100644 --- a/src/nvim/search.c +++ b/src/nvim/search.c @@ -1,37 +1,39 @@ // This is an open source non-commercial project. Dear PVS-Studio, please check // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com -/* - * search.c: code for normal mode searching commands - */ +// search.c: code for normal mode searching commands #include <assert.h> #include <inttypes.h> -#include <limits.h> // for INT_MAX on MSVC +#include <limits.h> #include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> #include <string.h> #include "nvim/ascii.h" +#include "nvim/autocmd.h" #include "nvim/buffer.h" +#include "nvim/buffer_defs.h" #include "nvim/change.h" #include "nvim/charset.h" #include "nvim/cmdhist.h" #include "nvim/cursor.h" #include "nvim/drawscreen.h" -#include "nvim/edit.h" #include "nvim/eval.h" -#include "nvim/eval/funcs.h" +#include "nvim/eval/typval.h" #include "nvim/ex_cmds.h" #include "nvim/ex_docmd.h" #include "nvim/ex_getln.h" #include "nvim/fileio.h" #include "nvim/fold.h" -#include "nvim/func_attr.h" #include "nvim/getchar.h" -#include "nvim/indent.h" +#include "nvim/gettext.h" +#include "nvim/globals.h" +#include "nvim/highlight_defs.h" #include "nvim/indent_c.h" #include "nvim/insexpand.h" -#include "nvim/main.h" +#include "nvim/macros.h" #include "nvim/mark.h" #include "nvim/mbyte.h" #include "nvim/memline.h" @@ -41,11 +43,13 @@ #include "nvim/move.h" #include "nvim/normal.h" #include "nvim/option.h" +#include "nvim/os/fs.h" #include "nvim/os/input.h" #include "nvim/os/time.h" #include "nvim/path.h" #include "nvim/profile.h" #include "nvim/regexp.h" +#include "nvim/screen.h" #include "nvim/search.h" #include "nvim/strings.h" #include "nvim/ui.h" @@ -82,8 +86,7 @@ // one for other searches. last_idx points to the one that was used the last // time. -static struct spat spats[2] = -{ +static struct spat spats[2] = { // Last used search pattern [0] = { NULL, true, false, 0, { '/', false, false, 0L }, NULL }, // Last used substitute pattern @@ -95,24 +98,23 @@ static int last_idx = 0; // index in spats[] for RE_LAST static char_u lastc[2] = { NUL, NUL }; // last character searched for static Direction 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 char lastc_bytes[MB_MAXBYTES + 1]; static int lastc_bytelen = 1; // >1 for multi-byte char // copy of spats[], for keeping the search patterns while executing autocmds static struct spat saved_spats[2]; +static char *saved_mr_pattern = NULL; static int saved_spats_last_idx = 0; static bool saved_spats_no_hlsearch = false; -static char_u *mr_pattern = NULL; // pattern used by search_regcomp() -static bool mr_pattern_alloced = false; // mr_pattern was allocated +// allocated copy of pattern used by search_regcomp() +static char *mr_pattern = NULL; -/* - * Type used by find_pattern_in_path() to remember which included files have - * been searched already. - */ +// Type used by find_pattern_in_path() to remember which included files have +// been searched already. typedef struct SearchedFile { FILE *fp; // File pointer - char_u *name; // Full name of file + char *name; // Full name of file linenr_T lnum; // Line we were up to in file int matched; // Found a match in this file } SearchedFile; @@ -131,17 +133,16 @@ typedef struct SearchedFile { /// @param regmatch return: pattern and ignore-case flag /// /// @return FAIL if failed, OK otherwise. -int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatch_T *regmatch) +int search_regcomp(char_u *pat, char_u **used_pat, int pat_save, int pat_use, int options, + regmmatch_T *regmatch) { int magic; int i; rc_did_emsg = false; - magic = p_magic; + magic = magic_isset(); - /* - * If no pattern given, use a previously defined pattern. - */ + // If no pattern given, use a previously defined pattern. if (pat == NULL || *pat == NUL) { if (pat_use == RE_LAST) { i = last_idx; @@ -157,41 +158,38 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc rc_did_emsg = true; return FAIL; } - pat = spats[i].pat; + pat = (char_u *)spats[i].pat; magic = spats[i].magic; no_smartcase = spats[i].no_scs; } else if (options & SEARCH_HIS) { // put new pattern in history - add_to_history(HIST_SEARCH, pat, true, NUL); + add_to_history(HIST_SEARCH, (char *)pat, true, NUL); } - if (mr_pattern_alloced) { - xfree(mr_pattern); - mr_pattern_alloced = false; + if (used_pat) { + *used_pat = pat; } + xfree(mr_pattern); if (curwin->w_p_rl && *curwin->w_p_rlc == 's') { - mr_pattern = (char_u *)reverse_text((char *)pat); - mr_pattern_alloced = true; + mr_pattern = reverse_text((char *)pat); } else { - mr_pattern = pat; + mr_pattern = xstrdup((char *)pat); } - /* - * Save the currently used pattern in the appropriate place, - * unless the pattern should not be remembered. - */ + // Save the currently used pattern in the appropriate place, + // unless the pattern should not be remembered. if (!(options & SEARCH_KEEP) && (cmdmod.cmod_flags & CMOD_KEEPPATTERNS) == 0) { // search or global command if (pat_save == RE_SEARCH || pat_save == RE_BOTH) { - save_re_pat(RE_SEARCH, pat, magic); + save_re_pat(RE_SEARCH, (char *)pat, magic); } // substitute or global command if (pat_save == RE_SUBST || pat_save == RE_BOTH) { - save_re_pat(RE_SUBST, pat, magic); + save_re_pat(RE_SUBST, (char *)pat, magic); } } - regmatch->rmm_ic = ignorecase(pat); + regmatch->rmm_ic = ignorecase((char *)pat); regmatch->rmm_maxcol = 0; regmatch->regprog = vim_regcomp((char *)pat, magic ? RE_MAGIC : 0); if (regmatch->regprog == NULL) { @@ -200,19 +198,17 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc return OK; } -/* - * Get search pattern used by search_regcomp(). - */ -char_u *get_search_pat(void) +/// Get search pattern used by search_regcomp(). +char *get_search_pat(void) { return mr_pattern; } -void save_re_pat(int idx, char_u *pat, int magic) +void save_re_pat(int idx, char *pat, int magic) { if (spats[idx].pat != pat) { free_spat(&spats[idx]); - spats[idx].pat = vim_strsave(pat); + spats[idx].pat = xstrdup(pat); spats[idx].magic = magic; spats[idx].no_scs = no_smartcase; spats[idx].timestamp = os_time(); @@ -226,10 +222,8 @@ void save_re_pat(int idx, char_u *pat, int magic) } } -/* - * Save the search patterns, so they can be restored later. - * Used before/after executing autocommands and user functions. - */ +// Save the search patterns, so they can be restored later. +// Used before/after executing autocommands and user functions. static int save_level = 0; void save_search_patterns(void) @@ -237,11 +231,16 @@ void save_search_patterns(void) if (save_level++ == 0) { saved_spats[0] = spats[0]; if (spats[0].pat != NULL) { - saved_spats[0].pat = vim_strsave(spats[0].pat); + saved_spats[0].pat = xstrdup(spats[0].pat); } saved_spats[1] = spats[1]; if (spats[1].pat != NULL) { - saved_spats[1].pat = vim_strsave(spats[1].pat); + saved_spats[1].pat = xstrdup(spats[1].pat); + } + if (mr_pattern == NULL) { + saved_mr_pattern = NULL; + } else { + saved_mr_pattern = xstrdup(mr_pattern); } saved_spats_last_idx = last_idx; saved_spats_no_hlsearch = no_hlsearch; @@ -256,6 +255,8 @@ void restore_search_patterns(void) set_vv_searchforward(); free_spat(&spats[1]); spats[1] = saved_spats[1]; + xfree(mr_pattern); + mr_pattern = saved_mr_pattern; last_idx = saved_spats_last_idx; set_no_hlsearch(saved_spats_no_hlsearch); } @@ -275,11 +276,7 @@ void free_search_patterns(void) CLEAR_FIELD(spats); - if (mr_pattern_alloced) { - xfree(mr_pattern); - mr_pattern_alloced = false; - mr_pattern = NULL; - } + XFREE_CLEAR(mr_pattern); } #endif @@ -308,7 +305,7 @@ void save_last_search_pattern(void) saved_last_search_spat = spats[RE_SEARCH]; if (spats[RE_SEARCH].pat != NULL) { - saved_last_search_spat.pat = vim_strsave(spats[RE_SEARCH].pat); + saved_last_search_spat.pat = xstrdup(spats[RE_SEARCH].pat); } saved_last_idx = last_idx; saved_no_hlsearch = no_hlsearch; @@ -351,24 +348,24 @@ static void restore_incsearch_state(void) char_u *last_search_pattern(void) { - return spats[RE_SEARCH].pat; + return (char_u *)spats[RE_SEARCH].pat; } /// Return true when case should be ignored for search pattern "pat". /// Uses the 'ignorecase' and 'smartcase' options. -int ignorecase(char_u *pat) +int ignorecase(char *pat) { return ignorecase_opt(pat, p_ic, p_scs); } /// As ignorecase() put pass the "ic" and "scs" flags. -int ignorecase_opt(char_u *pat, int ic_in, int scs) +int ignorecase_opt(char *pat, int ic_in, int scs) { int ic = ic_in; if (ic && !no_smartcase && scs && !(ctrl_x_mode_not_default() && curbuf->b_p_inf)) { - ic = !pat_has_uppercase(pat); + ic = !pat_has_uppercase((char_u *)pat); } no_smartcase = false; @@ -379,17 +376,21 @@ int ignorecase_opt(char_u *pat, int ic_in, int scs) bool pat_has_uppercase(char_u *pat) FUNC_ATTR_NONNULL_ALL { - char_u *p = pat; + char *p = (char *)pat; + magic_T magic_val = MAGIC_ON; + + // get the magicness of the pattern + (void)skip_regexp_ex((char *)pat, NUL, magic_isset(), NULL, NULL, &magic_val); while (*p != NUL) { - const int l = utfc_ptr2len((char *)p); + const int l = utfc_ptr2len(p); if (l > 1) { - if (mb_isupper(utf_ptr2char((char *)p))) { + if (mb_isupper(utf_ptr2char(p))) { return true; } p += l; - } else if (*p == '\\') { + } else if (*p == '\\' && magic_val <= MAGIC_ON) { if (p[1] == '_' && p[2] != NUL) { // skip "\_X" p += 3; } else if (p[1] == '%' && p[2] != NUL) { // skip "\%X" @@ -399,7 +400,13 @@ bool pat_has_uppercase(char_u *pat) } else { p += 1; } - } else if (mb_isupper(*p)) { + } else if ((*p == '%' || *p == '_') && magic_val == MAGIC_ALL) { + if (p[1] != NUL) { // skip "_X" and %X + p += 2; + } else { + p++; + } + } else if (mb_isupper((uint8_t)(*p))) { return true; } else { p++; @@ -411,7 +418,7 @@ bool pat_has_uppercase(char_u *pat) const char *last_csearch(void) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT { - return (const char *)lastc_bytes; + return lastc_bytes; } int last_csearch_forward(void) @@ -447,22 +454,18 @@ void set_csearch_until(int t_cmd) char_u *last_search_pat(void) { - return spats[last_idx].pat; + return (char_u *)spats[last_idx].pat; } -/* - * Reset search direction to forward. For "gd" and "gD" commands. - */ +// Reset search direction to forward. For "gd" and "gD" commands. void reset_search_dir(void) { spats[0].off.dir = '/'; set_vv_searchforward(); } -/* - * Set the last search pattern. For ":let @/ =" and ShaDa file. - * Also set the saved search pattern, so that this works in an autocommand. - */ +// Set the last search pattern. For ":let @/ =" and ShaDa file. +// Also set the saved search pattern, so that this works in an autocommand. void set_last_search_pat(const char_u *s, int idx, int magic, int setlast) { free_spat(&spats[idx]); @@ -470,7 +473,7 @@ void set_last_search_pat(const char_u *s, int idx, int magic, int setlast) if (*s == NUL) { spats[idx].pat = NULL; } else { - spats[idx].pat = (char_u *)xstrdup((char *)s); + spats[idx].pat = xstrdup((char *)s); } spats[idx].timestamp = os_time(); spats[idx].additional_data = NULL; @@ -490,7 +493,7 @@ void set_last_search_pat(const char_u *s, int idx, int magic, int setlast) if (spats[idx].pat == NULL) { saved_spats[idx].pat = NULL; } else { - saved_spats[idx].pat = vim_strsave(spats[idx].pat); + saved_spats[idx].pat = xstrdup(spats[idx].pat); } saved_spats_last_idx = last_idx; } @@ -500,11 +503,9 @@ void set_last_search_pat(const char_u *s, int idx, int magic, int setlast) } } -/* - * Get a regexp program for the last used search pattern. - * This is used for highlighting all matches in a window. - * Values returned in regmatch->regprog and regmatch->rmm_ic. - */ +// Get a regexp program for the last used search pattern. +// This is used for highlighting all matches in a window. +// Values returned in regmatch->regprog and regmatch->rmm_ic. void last_pat_prog(regmmatch_T *regmatch) { if (spats[last_idx].pat == NULL) { @@ -512,7 +513,7 @@ void last_pat_prog(regmmatch_T *regmatch) return; } emsg_off++; // So it doesn't beep if bad expr - (void)search_regcomp((char_u *)"", 0, last_idx, SEARCH_KEEP, regmatch); + (void)search_regcomp((char_u *)"", NULL, 0, last_idx, SEARCH_KEEP, regmatch); emsg_off--; } @@ -545,7 +546,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, int found; linenr_T lnum; // no init to shut up Apollo cc regmmatch_T regmatch; - char_u *ptr; + char *ptr; colnr_T matchcol; lpos_T endpos; lpos_T matchpos; @@ -570,7 +571,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, timed_out = &extra_arg->sa_timed_out; } - if (search_regcomp(pat, RE_SEARCH, pat_use, + if (search_regcomp(pat, NULL, RE_SEARCH, pat_use, (options & (SEARCH_HIS + SEARCH_KEEP)), ®match) == FAIL) { if ((options & SEARCH_MSG) && !rc_did_emsg) { semsg(_("E383: Invalid search string: %s"), mr_pattern); @@ -578,9 +579,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, return FAIL; } - /* - * find the string - */ + // find the string 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 @@ -592,10 +591,10 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, && pos->col < MAXCOL - 2) { // Watch out for the "col" being MAXCOL - 2, used in a closed fold. ptr = ml_get_buf(buf, pos->lnum, false); - if ((int)STRLEN(ptr) <= pos->col) { + if ((int)strlen(ptr) <= pos->col) { start_char_len = 1; } else { - start_char_len = utfc_ptr2len((char *)ptr + pos->col); + start_char_len = utfc_ptr2len(ptr + pos->col); } } else { start_char_len = 1; @@ -615,13 +614,11 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, at_first_line = false; // not in first line now } - /* - * Start searching in current line, unless searching backwards and - * we're in column 0. - * If we are searching backwards, in column 0, and not including the - * current position, gain some efficiency by skipping back a line. - * Otherwise begin the search in the current line. - */ + // Start searching in current line, unless searching backwards and + // we're in column 0. + // If we are searching backwards, in column 0, and not including the + // current position, gain some efficiency by skipping back a line. + // Otherwise begin the search in the current line. if (dir == BACKWARD && start_pos.col == 0 && (options & SEARCH_START) == 0) { lnum = pos->lnum - 1; @@ -662,18 +659,17 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, submatch = first_submatch(®match); // "lnum" may be past end of buffer for "\n\zs". if (lnum + matchpos.lnum > buf->b_ml.ml_line_count) { - ptr = (char_u *)""; + ptr = ""; } else { ptr = ml_get_buf(buf, lnum + matchpos.lnum, false); } - /* - * Forward search in the first line: match should be after - * the start position. If not, continue at the end of the - * match (this is vi compatible) or on the next char. - */ + // Forward search in the first line: match should be after + // the start position. If not, continue at the end of the + // match (this is vi compatible) or on the next char. if (dir == FORWARD && at_first_line) { match_ok = true; + // When the match starts in a next line it's certainly // past the start position. // When match lands on a NUL the cursor will be put @@ -687,11 +683,9 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, : ((int)matchpos.col - (ptr[matchpos.col] == NUL) < (int)start_pos.col + extra_col))) { - /* - * If vi-compatible searching, continue at the end - * of the match, otherwise continue one position - * forward. - */ + // If vi-compatible searching, continue at the end + // of the match, otherwise continue one position + // forward. if (vim_strchr(p_cpo, CPO_SEARCH) != NULL) { if (nmatched > 1) { // end is in next line, thus no match in @@ -700,20 +694,22 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, break; } matchcol = endpos.col; - // for empty match (matchcol == matchpos.col): advance one char + // for empty match: advance one char + if (matchcol == matchpos.col && ptr[matchcol] != NUL) { + matchcol += utfc_ptr2len(ptr + matchcol); + } } else { - // Prepare to start after first matched character. - matchcol = matchpos.col; - } - - if (matchcol == matchpos.col && ptr[matchcol] != NUL) { - matchcol += utfc_ptr2len((char *)ptr + matchcol); + // Advance "matchcol" to the next character. + // This uses rmm_matchcol, the actual start of + // the match, ignoring "\zs". + matchcol = regmatch.rmm_matchcol; + if (ptr[matchcol] != NUL) { + matchcol += utfc_ptr2len(ptr + matchcol); + } } - if (matchcol == 0 && (options & SEARCH_START)) { break; } - if (ptr[matchcol] == NUL || (nmatched = vim_regexec_multi(®match, win, buf, lnum, matchcol, tm, @@ -744,13 +740,11 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, } } if (dir == BACKWARD) { - /* - * Now, if there are multiple matches on this line, - * we have to get the last one. Or the last one before - * the cursor, if we're on that line. - * When putting the new cursor at the end, compare - * relative to the end of the match. - */ + // Now, if there are multiple matches on this line, + // we have to get the last one. Or the last one before + // the cursor, if we're on that line. + // When putting the new cursor at the end, compare + // relative to the end of the match. match_ok = false; for (;;) { // Remember a position that is before the start @@ -792,7 +786,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, // for empty match: advance one char if (matchcol == matchpos.col && ptr[matchcol] != NUL) { - matchcol += utfc_ptr2len((char *)ptr + matchcol); + matchcol += utfc_ptr2len(ptr + matchcol); } } else { // Stop when the match is in a next line. @@ -801,13 +795,12 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, } matchcol = matchpos.col; if (ptr[matchcol] != NUL) { - matchcol += utfc_ptr2len((char *)ptr + matchcol); + matchcol += utfc_ptr2len(ptr + matchcol); } } if (ptr[matchcol] == NUL - || (nmatched = - vim_regexec_multi(®match, win, buf, lnum + matchpos.lnum, matchcol, - tm, timed_out)) == 0) { + || (nmatched = vim_regexec_multi(®match, win, buf, lnum + matchpos.lnum, + matchcol, tm, timed_out)) == 0) { // If the search timed out, we did find a match // but it might be the wrong one, so that's not // OK. @@ -825,10 +818,8 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, ptr = ml_get_buf(buf, lnum + matchpos.lnum, false); } - /* - * If there is only a match after the cursor, skip - * this match. - */ + // If there is only a match after the cursor, skip + // this match. if (!match_ok) { continue; } @@ -847,7 +838,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, if (endpos.col == 0) { if (pos->lnum > 1) { // just in case pos->lnum--; - pos->col = (colnr_T)STRLEN(ml_get_buf(buf, pos->lnum, false)); + pos->col = (colnr_T)strlen(ml_get_buf(buf, pos->lnum, false)); } } else { pos->col--; @@ -964,7 +955,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir, // 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; - pos->col = (int)STRLEN(ml_get_buf(buf, pos->lnum, false)); + pos->col = (int)strlen(ml_get_buf(buf, pos->lnum, false)); if (pos->col > 0) { pos->col--; } @@ -1026,41 +1017,35 @@ static int first_submatch(regmmatch_T *rp) /// @param sia optional arguments or NULL /// /// @return 0 for failure, 1 for found, 2 for found and line offset added. -int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, int options, +int do_search(oparg_T *oap, int dirc, int search_delim, char *pat, long count, int options, searchit_arg_T *sia) { pos_T pos; // position of the last match - char_u *searchstr; + char *searchstr; struct soffset old_off; int retval; // Return value - char_u *p; + char *p; long c; - char_u *dircp; + char *dircp; char *strcopy = NULL; - char_u *ps; - char_u *msgbuf = NULL; + char *ps; + char *msgbuf = NULL; size_t len; bool has_offset = false; - /* - * A line offset is not remembered, this is vi compatible. - */ + // A line offset is not remembered, this is vi compatible. if (spats[0].off.line && vim_strchr(p_cpo, CPO_LINEOFF) != NULL) { spats[0].off.line = false; spats[0].off.off = 0; } - /* - * Save the values for when (options & SEARCH_KEEP) is used. - * (there is no "if ()" around this because gcc wants them initialized) - */ + // Save the values for when (options & SEARCH_KEEP) is used. + // (there is no "if ()" around this because gcc wants them initialized) old_off = spats[0].off; pos = curwin->w_cursor; // start searching at the cursor position - /* - * Find out the direction of the search. - */ + // Find out the direction of the search. if (dirc == 0) { dirc = (char_u)spats[0].off.dir; } else { @@ -1087,17 +1072,13 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, } } - /* - * Turn 'hlsearch' highlighting back on. - */ + // Turn 'hlsearch' highlighting back on. if (no_hlsearch && !(options & SEARCH_KEEP)) { redraw_all_later(UPD_SOME_VALID); set_no_hlsearch(false); } - /* - * Repeat the search when pattern followed by ';', e.g. "/foo/;?bar". - */ + // Repeat the search when pattern followed by ';', e.g. "/foo/;?bar". for (;;) { bool show_top_bot_msg = false; @@ -1114,22 +1095,20 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, } } else { // make search_regcomp() use spats[RE_SEARCH].pat - searchstr = (char_u *)""; + searchstr = ""; } } if (pat != NULL && *pat != NUL) { // look for (new) offset - /* - * Find end of regular expression. - * If there is a matching '/' or '?', toss it. - */ - ps = (char_u *)strcopy; - p = (char_u *)skip_regexp((char *)pat, search_delim, p_magic, &strcopy); - if (strcopy != (char *)ps) { + // Find end of regular expression. + // If there is a matching '/' or '?', toss it. + ps = strcopy; + p = skip_regexp_ex(pat, search_delim, magic_isset(), &strcopy, NULL, NULL); + if (strcopy != ps) { // made a copy of "pat" to change "\?" to "?" - searchcmdlen += (int)(STRLEN(pat) - STRLEN(strcopy)); - pat = (char_u *)strcopy; - searchstr = (char_u *)strcopy; + searchcmdlen += (int)(strlen(pat) - strlen(strcopy)); + pat = strcopy; + searchstr = strcopy; } if (*p == search_delim) { dircp = p; // remember where we put the NUL @@ -1154,7 +1133,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, if (ascii_isdigit(*p) || *p == '+' || *p == '-') { // got an offset // 'nr' or '+nr' or '-nr' if (ascii_isdigit(*p) || ascii_isdigit(*(p + 1))) { - spats[0].off.off = atol((char *)p); + spats[0].off.off = atol(p); } else if (*p == '-') { // single '-' spats[0].off.off = -1; } else { // single '+' @@ -1174,8 +1153,8 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, if ((options & SEARCH_ECHO) && messaging() && !msg_silent && (!cmd_silent || !shortmess(SHM_SEARCHCOUNT))) { - char_u *trunc; - char_u off_buf[40]; + char *trunc; + char off_buf[40]; size_t off_len = 0; // Compute msg_row early. @@ -1185,7 +1164,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, if (!cmd_silent && (spats[0].off.line || spats[0].off.end || spats[0].off.off)) { p = off_buf; // -V507 - *p++ = (char_u)dirc; + *p++ = (char)dirc; if (spats[0].off.end) { *p++ = 'e'; } else if (!spats[0].off.line) { @@ -1196,10 +1175,10 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, } *p = NUL; if (spats[0].off.off != 0 || spats[0].off.line) { - snprintf((char *)p, sizeof(off_buf) - 1 - (size_t)(p - off_buf), + snprintf(p, sizeof(off_buf) - 1 - (size_t)(p - off_buf), "%" PRId64, spats[0].off.off); } - off_len = STRLEN(off_buf); + off_len = strlen(off_buf); } if (*searchstr == NUL) { @@ -1222,12 +1201,12 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, // Use up to 'showcmd' column. len = (size_t)((Rows - msg_row - 1) * Columns + sc_col - 1); } - if (len < STRLEN(p) + off_len + SEARCH_STAT_BUF_LEN + 3) { - len = STRLEN(p) + off_len + SEARCH_STAT_BUF_LEN + 3; + if (len < strlen(p) + off_len + SEARCH_STAT_BUF_LEN + 3) { + len = strlen(p) + off_len + SEARCH_STAT_BUF_LEN + 3; } } else { // Reserve enough space for the search pattern + offset. - len = STRLEN(p) + off_len + 3; + len = strlen(p) + off_len + 3; } xfree(msgbuf); @@ -1238,16 +1217,16 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, // do not fill the msgbuf buffer, if cmd_silent is set, leave it // empty for the search_stat feature. if (!cmd_silent) { - msgbuf[0] = (char_u)dirc; - if (utf_iscomposing(utf_ptr2char((char *)p))) { + msgbuf[0] = (char)dirc; + if (utf_iscomposing(utf_ptr2char(p))) { // Use a space to draw the composing char on. msgbuf[1] = ' '; - memmove(msgbuf + 2, p, STRLEN(p)); + memmove(msgbuf + 2, p, strlen(p)); } else { - memmove(msgbuf + 1, p, STRLEN(p)); + memmove(msgbuf + 1, p, strlen(p)); } if (off_len > 0) { - memmove(msgbuf + STRLEN(p) + 1, off_buf, off_len); + memmove(msgbuf + strlen(p) + 1, off_buf, off_len); } trunc = msg_strtrunc(msgbuf, true); @@ -1261,14 +1240,14 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, // it would be blanked out again very soon. Show it on the // left, but do reverse the text. if (curwin->w_p_rl && *curwin->w_p_rlc == 's') { - char_u *r = (char_u *)reverse_text(trunc != NULL ? (char *)trunc : (char *)msgbuf); + char *r = reverse_text(trunc != NULL ? trunc : msgbuf); xfree(msgbuf); msgbuf = r; // move reversed text to beginning of buffer while (*r == ' ') { r++; } - size_t pat_len = (size_t)(msgbuf + STRLEN(msgbuf) - r); + size_t pat_len = (size_t)(msgbuf + strlen(msgbuf) - r); memmove(msgbuf, r, pat_len); // overwrite old text if ((size_t)(r - msgbuf) >= pat_len) { @@ -1277,7 +1256,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, memset(msgbuf + pat_len, ' ', (size_t)(r - msgbuf)); } } - msg_outtrans((char *)msgbuf); + msg_outtrans(msgbuf); msg_clr_eos(); msg_check(); @@ -1287,13 +1266,11 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, } } - /* - * If there is a character offset, subtract it from the current - * position, so we don't get stuck at "?pat?e+2" or "/pat/s-2". - * Skip this if pos.col is near MAXCOL (closed fold). - * This is not done for a line offset, because then we would not be vi - * compatible. - */ + // If there is a character offset, subtract it from the current + // position, so we don't get stuck at "?pat?e+2" or "/pat/s-2". + // Skip this if pos.col is near MAXCOL (closed fold). + // This is not done for a line offset, because then we would not be vi + // compatible. if (!spats[0].off.line && spats[0].off.off && pos.col < MAXCOL - 2) { if (spats[0].off.off > 0) { for (c = spats[0].off.off; c; c--) { @@ -1319,7 +1296,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, } c = searchit(curwin, curbuf, &pos, NULL, dirc == '/' ? FORWARD : BACKWARD, - searchstr, count, + (char_u *)searchstr, count, (spats[0].off.end * SEARCH_END + (options & (SEARCH_KEEP + SEARCH_PEEK + SEARCH_HIS + SEARCH_MSG @@ -1328,7 +1305,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, RE_LAST, sia); if (dircp != NULL) { - *dircp = (char_u)search_delim; // restore second '/' or '?' for normal_cmd() + *dircp = (char)search_delim; // restore second '/' or '?' for normal_cmd() } if (!shortmess(SHM_SEARCH) @@ -1350,9 +1327,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, apply_autocmds(EVENT_SEARCHWRAPPED, NULL, NULL, false, NULL); } - /* - * Add character and/or line offset - */ + // Add character and/or line offset if (!(options & SEARCH_NOOF) || (pat != NULL && *pat == ';')) { pos_T org_pos = pos; @@ -1377,9 +1352,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, break; } } - } - // to the left, check for start of file - else { + } else { // to the left, check for start of file while (c++ < 0) { if (decl(&pos) == -1) { break; @@ -1419,7 +1392,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, break; } - dirc = *++pat; + dirc = (uint8_t)(*++pat); search_delim = dirc; if (dirc != '?' && dirc != '/') { retval = 0; @@ -1439,25 +1412,24 @@ end_do_search: if ((options & SEARCH_KEEP) || (cmdmod.cmod_flags & CMOD_KEEPPATTERNS)) { spats[0].off = old_off; } + xfree(strcopy); xfree(msgbuf); return retval; } -/* - * search_for_exact_line(buf, pos, dir, pat) - * - * Search for a line starting with the given pattern (ignoring leading - * white-space), starting from pos and going in direction "dir". "pos" will - * contain the position of the match found. Blank lines match only if - * ADDING is set. If p_ic is set then the pattern must be in lowercase. - * Return OK for success, or FAIL if no line found. - */ -int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat) +// search_for_exact_line(buf, pos, dir, pat) +// +// Search for a line starting with the given pattern (ignoring leading +// white-space), starting from pos and going in direction "dir". "pos" will +// contain the position of the match found. Blank lines match only if +// ADDING is set. If p_ic is set then the pattern must be in lowercase. +// Return OK for success, or FAIL if no line found. +int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char *pat) { linenr_T start = 0; - char_u *ptr; - char_u *p; + char *ptr; + char *p; if (buf->b_ml.ml_line_count == 0) { return FAIL; @@ -1492,7 +1464,7 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat) start = pos->lnum; } ptr = ml_get_buf(buf, pos->lnum, false); - p = (char_u *)skipwhite((char *)ptr); + p = skipwhite(ptr); pos->col = (colnr_T)(p - ptr); // when adding lines the matching line may be empty but it is not @@ -1505,7 +1477,7 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat) // Expanding lines or words. assert(ins_compl_len() >= 0); if ((p_ic ? mb_strnicmp(p, pat, (size_t)ins_compl_len()) - : STRNCMP(p, pat, ins_compl_len())) == 0) { + : strncmp(p, pat, (size_t)ins_compl_len())) == 0) { return OK; } } @@ -1513,9 +1485,7 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat) return FAIL; } -/* - * Character Searches - */ +// Character Searches /// Search for a character in a line. If "t_cmd" is false, move to the /// position of the character, otherwise move to just before the char. @@ -1528,7 +1498,7 @@ int searchc(cmdarg_T *cap, int t_cmd) int dir = cap->arg; // true for searching forward long count = cap->count1; // repeat count int col; - char_u *p; + char *p; int len; bool stop = true; @@ -1537,13 +1507,13 @@ int searchc(cmdarg_T *cap, int t_cmd) *lastc = (char_u)c; set_csearch_direction(dir); set_csearch_until(t_cmd); - lastc_bytelen = utf_char2bytes(c, (char *)lastc_bytes); + lastc_bytelen = utf_char2bytes(c, lastc_bytes); if (cap->ncharC1 != 0) { lastc_bytelen += utf_char2bytes(cap->ncharC1, - (char *)lastc_bytes + lastc_bytelen); + lastc_bytes + lastc_bytelen); if (cap->ncharC2 != 0) { lastc_bytelen += utf_char2bytes(cap->ncharC2, - (char *)lastc_bytes + lastc_bytelen); + lastc_bytes + lastc_bytelen); } } } @@ -1576,12 +1546,12 @@ int searchc(cmdarg_T *cap, int t_cmd) p = get_cursor_line_ptr(); col = curwin->w_cursor.col; - len = (int)STRLEN(p); + len = (int)strlen(p); while (count--) { for (;;) { if (dir > 0) { - col += utfc_ptr2len((char *)p + col); + col += utfc_ptr2len(p + col); if (col >= len) { return FAIL; } @@ -1595,7 +1565,7 @@ int searchc(cmdarg_T *cap, int t_cmd) if (p[col] == c && stop) { break; } - } else if (STRNCMP(p + col, lastc_bytes, lastc_bytelen) == 0 && stop) { + } else if (strncmp(p + col, lastc_bytes, (size_t)lastc_bytelen) == 0 && stop) { break; } stop = true; @@ -1618,15 +1588,11 @@ int searchc(cmdarg_T *cap, int t_cmd) return OK; } -/* - * "Other" Searches - */ +// "Other" Searches -/* - * findmatch - find the matching paren or brace - * - * Improvement over vi: Braces inside quotes are ignored. - */ +// findmatch - find the matching paren or brace +// +// Improvement over vi: Braces inside quotes are ignored. pos_T *findmatch(oparg_T *oap, int initc) { return findmatchlimit(oap, initc, 0, 0); @@ -1637,7 +1603,7 @@ pos_T *findmatch(oparg_T *oap, int initc) // Update "*prevcol" to the column of the previous character, unless "prevcol" // is NULL. // Handles multibyte string correctly. -static bool check_prevcol(char_u *linep, int col, int ch, int *prevcol) +static bool check_prevcol(char *linep, int col, int ch, int *prevcol) { col--; if (col > 0) { @@ -1646,32 +1612,31 @@ static bool check_prevcol(char_u *linep, int col, int ch, int *prevcol) if (prevcol) { *prevcol = col; } - return col >= 0 && linep[col] == ch; + return col >= 0 && (uint8_t)linep[col] == ch; } -/* - * Raw string start is found at linep[startpos.col - 1]. - * Return true if the matching end can be found between startpos and endpos. - */ -static bool find_rawstring_end(char_u *linep, pos_T *startpos, pos_T *endpos) +/// Raw string start is found at linep[startpos.col - 1]. +/// +/// @return true if the matching end can be found between startpos and endpos. +static bool find_rawstring_end(char *linep, pos_T *startpos, pos_T *endpos) { - char_u *p; + char *p; linenr_T lnum; for (p = linep + startpos->col + 1; *p && *p != '('; p++) {} size_t delim_len = (size_t)((p - linep) - startpos->col - 1); - char_u *delim_copy = vim_strnsave(linep + startpos->col + 1, delim_len); + char *delim_copy = xstrnsave(linep + startpos->col + 1, delim_len); bool found = false; for (lnum = startpos->lnum; lnum <= endpos->lnum; lnum++) { - char_u *line = ml_get(lnum); + char *line = ml_get(lnum); for (p = line + (lnum == startpos->lnum ? startpos->col + 1 : 0); *p; p++) { if (lnum == endpos->lnum && (colnr_T)(p - line) >= endpos->col) { break; } if (*p == ')' - && STRNCMP(delim_copy, p + 1, delim_len) == 0 + && strncmp(delim_copy, p + 1, delim_len) == 0 && p[delim_len + 1] == '"') { found = true; break; @@ -1726,27 +1691,24 @@ static void find_mps_values(int *initc, int *findc, bool *backwards, bool switch } } -/* - * findmatchlimit -- find the matching paren or brace, if it exists within - * maxtravel lines of the cursor. A maxtravel of 0 means search until falling - * off the edge of the file. - * - * "initc" is the character to find a match for. NUL means to find the - * character at or after the cursor. Special values: - * '*' look for C-style comment / * - * '/' look for C-style comment / *, ignoring comment-end - * '#' look for preprocessor directives - * 'R' look for raw string start: R"delim(text)delim" (only backwards) - * - * flags: FM_BACKWARD search backwards (when initc is '/', '*' or '#') - * FM_FORWARD search forwards (when initc is '/', '*' or '#') - * FM_BLOCKSTOP stop at start/end of block ({ or } in column 0) - * FM_SKIPCOMM skip comments (not implemented yet!) - * - * "oap" is only used to set oap->motion_type for a linewise motion, it can be - * NULL - */ - +// findmatchlimit -- find the matching paren or brace, if it exists within +// maxtravel lines of the cursor. A maxtravel of 0 means search until falling +// off the edge of the file. +// +// "initc" is the character to find a match for. NUL means to find the +// character at or after the cursor. Special values: +// '*' look for C-style comment / * +// '/' look for C-style comment / *, ignoring comment-end +// '#' look for preprocessor directives +// 'R' look for raw string start: R"delim(text)delim" (only backwards) +// +// flags: FM_BACKWARD search backwards (when initc is '/', '*' or '#') +// FM_FORWARD search forwards (when initc is '/', '*' or '#') +// FM_BLOCKSTOP stop at start/end of block ({ or } in column 0) +// FM_SKIPCOMM skip comments (not implemented yet!) +// +// "oap" is only used to set oap->motion_type for a linewise motion, it can be +// NULL pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) { static pos_T pos; // current search position @@ -1755,7 +1717,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) bool backwards = false; // init for gcc bool raw_string = false; // search for raw string bool inquote = false; // true when inside quotes - char_u *ptr; + char *ptr; int hash_dir = 0; // Direction searched for # things int comment_dir = 0; // Direction searched for comments int traveled = 0; // how far we've searched so far @@ -1768,7 +1730,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) pos = curwin->w_cursor; pos.coladd = 0; - char_u *linep = ml_get(pos.lnum); // pointer to current line + char *linep = ml_get(pos.lnum); // pointer to current line // vi compatible matching bool cpo_match = (vim_strchr(p_cpo, CPO_MATCH) != NULL); @@ -1784,12 +1746,10 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) dir = 0; } - /* - * if initc given, look in the table for the matching character - * '/' and '*' are special cases: look for start or end of comment. - * When '/' is used, we ignore running backwards into a star-slash, for - * "[*" command, we just want to find any comment. - */ + // if initc given, look in the table for the matching character + // '/' and '*' are special cases: look for start or end of comment. + // When '/' is used, we ignore running backwards into a star-slash, for + // "[*" command, we just want to find any comment. if (initc == '/' || initc == '*' || initc == 'R') { comment_dir = dir; if (initc == '/') { @@ -1807,31 +1767,25 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) return NULL; } } else { - /* - * Either initc is '#', or no initc was given and we need to look - * under the cursor. - */ + // Either initc is '#', or no initc was given and we need to look + // under the cursor. if (initc == '#') { hash_dir = dir; } else { - /* - * initc was not given, must look for something to match under - * or near the cursor. - * Only check for special things when 'cpo' doesn't have '%'. - */ + // initc was not given, must look for something to match under + // or near the cursor. + // Only check for special things when 'cpo' doesn't have '%'. if (!cpo_match) { // Are we before or at #if, #else etc.? - ptr = (char_u *)skipwhite((char *)linep); + ptr = skipwhite(linep); if (*ptr == '#' && pos.col <= (colnr_T)(ptr - linep)) { - ptr = (char_u *)skipwhite((char *)ptr + 1); - if (STRNCMP(ptr, "if", 2) == 0 - || STRNCMP(ptr, "endif", 5) == 0 - || STRNCMP(ptr, "el", 2) == 0) { + ptr = skipwhite(ptr + 1); + if (strncmp(ptr, "if", 2) == 0 + || strncmp(ptr, "endif", 5) == 0 + || strncmp(ptr, "el", 2) == 0) { hash_dir = 1; } - } - // Are we on a comment? - else if (linep[pos.col] == '/') { + } else if (linep[pos.col] == '/') { // Are we on a comment? if (linep[pos.col + 1] == '*') { comment_dir = FORWARD; backwards = false; @@ -1852,21 +1806,17 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) } } - /* - * If we are not on a comment or the # at the start of a line, then - * look for brace anywhere on this line after the cursor. - */ + // If we are not on a comment or the # at the start of a line, then + // look for brace anywhere on this line after the cursor. if (!hash_dir && !comment_dir) { - /* - * Find the brace under or after the cursor. - * If beyond the end of the line, use the last character in - * the line. - */ + // Find the brace under or after the cursor. + // If beyond the end of the line, use the last character in + // the line. if (linep[pos.col] == NUL && pos.col) { pos.col--; } for (;;) { - initc = utf_ptr2char((char *)linep + pos.col); + initc = utf_ptr2char(linep + pos.col); if (initc == NUL) { break; } @@ -1875,11 +1825,11 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) if (findc) { break; } - pos.col += utfc_ptr2len((char *)linep + pos.col); + pos.col += utfc_ptr2len(linep + pos.col); } if (!findc) { // no brace in the line, maybe use " #if" then - if (!cpo_match && *skipwhite((char *)linep) == '#') { + if (!cpo_match && *skipwhite(linep) == '#') { hash_dir = 1; } else { return NULL; @@ -1897,17 +1847,15 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) } } if (hash_dir) { - /* - * Look for matching #if, #else, #elif, or #endif - */ + // Look for matching #if, #else, #elif, or #endif if (oap != NULL) { oap->motion_type = kMTLineWise; // Linewise for this case only } if (initc != '#') { - ptr = (char_u *)skipwhite(skipwhite((char *)linep) + 1); - if (STRNCMP(ptr, "if", 2) == 0 || STRNCMP(ptr, "el", 2) == 0) { + ptr = skipwhite(skipwhite(linep) + 1); + if (strncmp(ptr, "if", 2) == 0 || strncmp(ptr, "el", 2) == 0) { hash_dir = 1; - } else if (STRNCMP(ptr, "endif", 5) == 0) { + } else if (strncmp(ptr, "endif", 5) == 0) { hash_dir = -1; } else { return NULL; @@ -1925,36 +1873,36 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) pos.lnum += hash_dir; linep = ml_get(pos.lnum); line_breakcheck(); // check for CTRL-C typed - ptr = (char_u *)skipwhite((char *)linep); + ptr = skipwhite(linep); if (*ptr != '#') { continue; } pos.col = (colnr_T)(ptr - linep); - ptr = (char_u *)skipwhite((char *)ptr + 1); + ptr = skipwhite(ptr + 1); if (hash_dir > 0) { - if (STRNCMP(ptr, "if", 2) == 0) { + if (strncmp(ptr, "if", 2) == 0) { count++; - } else if (STRNCMP(ptr, "el", 2) == 0) { + } else if (strncmp(ptr, "el", 2) == 0) { if (count == 0) { return &pos; } - } else if (STRNCMP(ptr, "endif", 5) == 0) { + } else if (strncmp(ptr, "endif", 5) == 0) { if (count == 0) { return &pos; } count--; } } else { - if (STRNCMP(ptr, "if", 2) == 0) { + if (strncmp(ptr, "if", 2) == 0) { if (count == 0) { return &pos; } count--; - } else if (initc == '#' && STRNCMP(ptr, "el", 2) == 0) { + } else if (initc == '#' && strncmp(ptr, "el", 2) == 0) { if (count == 0) { return &pos; } - } else if (STRNCMP(ptr, "endif", 5) == 0) { + } else if (strncmp(ptr, "endif", 5) == 0) { count++; } } @@ -1977,17 +1925,15 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) // backward search: Check if this line contains a single-line comment if ((backwards && comment_dir) || lisp) { - comment_col = check_linecomment((char *)linep); + comment_col = check_linecomment(linep); } if (lisp && comment_col != MAXCOL && pos.col > (colnr_T)comment_col) { lispcomm = true; // find match inside this comment } while (!got_int) { - /* - * Go to the next position, forward or backward. We could use - * inc() and dec() here, but that is much slower - */ + // Go to the next position, forward or backward. We could use + // inc() and dec() here, but that is much slower if (backwards) { // char to match is inside of comment, don't search outside if (lispcomm && pos.col < (colnr_T)comment_col) { @@ -2004,13 +1950,13 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) } 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 if (comment_dir || lisp) { - comment_col = check_linecomment((char *)linep); + comment_col = check_linecomment(linep); } // skip comment if (lisp && comment_col != MAXCOL) { @@ -2043,10 +1989,10 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) do_quotes = -1; line_breakcheck(); if (lisp) { // find comment pos in new line - comment_col = check_linecomment((char *)linep); + comment_col = check_linecomment(linep); } } else { - pos.col += utfc_ptr2len((char *)linep + pos.col); + pos.col += utfc_ptr2len(linep + pos.col); } } @@ -2061,23 +2007,21 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) if (comment_dir) { // Note: comments do not nest, and we ignore quotes in them - // TODO: ignore comment brackets inside strings + // TODO(vim): ignore comment brackets inside strings if (comment_dir == FORWARD) { if (linep[pos.col] == '*' && linep[pos.col + 1] == '/') { pos.col++; return &pos; } } else { // Searching backwards - /* - * A comment may contain / * or / /, it may also start or end - * with / * /. Ignore a / * after / / and after *. - */ + // A comment may contain / * or / /, it may also start or end + // with / * /. Ignore a / * after / / and after *. if (pos.col == 0) { continue; } else if (raw_string) { if (linep[pos.col - 1] == 'R' && linep[pos.col] == '"' - && vim_strchr((char *)linep + pos.col + 1, '(') != NULL) { + && 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 @@ -2114,18 +2058,14 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) continue; } - /* - * If smart matching ('cpoptions' does not contain '%'), braces inside - * of quotes are ignored, but only if there is an even number of - * quotes in the line. - */ + // If smart matching ('cpoptions' does not contain '%'), braces inside + // of quotes are ignored, but only if there is an even number of + // quotes in the line. if (cpo_match) { do_quotes = 0; } else if (do_quotes == -1) { - /* - * Count the number of quotes in the line, skipping \" and '"'. - * Watch out for "\\". - */ + // Count the number of quotes in the line, skipping \" and '"'. + // Watch out for "\\". at_start = do_quotes; for (ptr = linep; *ptr; ptr++) { if (ptr == linep + pos.col + backwards) { @@ -2141,10 +2081,8 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) } do_quotes &= 1; // result is 1 with even number of quotes - /* - * If we find an uneven count, check current line and previous - * one for a '\' at the end. - */ + // If we find an uneven count, check current line and previous + // one for a '\' at the end. if (!do_quotes) { inquote = false; if (ptr[-1] == '\\') { @@ -2159,7 +2097,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) } if (pos.lnum > 1) { ptr = ml_get(pos.lnum - 1); - if (*ptr && *(ptr + STRLEN(ptr) - 1) == '\\') { + if (*ptr && *(ptr + strlen(ptr) - 1) == '\\') { do_quotes = 1; if (start_in_quotes == kNone) { inquote = at_start; @@ -2180,18 +2118,16 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) start_in_quotes = kFalse; } - /* - * If 'smartmatch' is set: - * Things inside quotes are ignored by setting 'inquote'. If we - * find a quote without a preceding '\' invert 'inquote'. At the - * end of a line not ending in '\' we reset 'inquote'. - * - * In lines with an uneven number of quotes (without preceding '\') - * we do not know which part to ignore. Therefore we only set - * inquote if the number of quotes in a line is even, unless this - * line or the previous one ends in a '\'. Complicated, isn't it? - */ - const int c = utf_ptr2char((char *)linep + pos.col); + // If 'smartmatch' is set: + // Things inside quotes are ignored by setting 'inquote'. If we + // find a quote without a preceding '\' invert 'inquote'. At the + // end of a line not ending in '\' we reset 'inquote'. + // + // In lines with an uneven number of quotes (without preceding '\') + // we do not know which part to ignore. Therefore we only set + // inquote if the number of quotes in a line is even, unless this + // line or the previous one ends in a '\'. Complicated, isn't it? + const int c = utf_ptr2char(linep + pos.col); switch (c) { case NUL: // at end of line without trailing backslash, reset inquote @@ -2219,13 +2155,11 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) } break; - /* - * If smart matching ('cpoptions' does not contain '%'): - * Skip things in single quotes: 'x' or '\x'. Be careful for single - * single quotes, eg jon's. Things like '\233' or '\x3f' are not - * skipped, there is never a brace in them. - * Ignore this when finding matches for `'. - */ + // If smart matching ('cpoptions' does not contain '%'): + // Skip things in single quotes: 'x' or '\x'. Be careful for single + // single quotes, eg jon's. Things like '\233' or '\x3f' are not + // skipped, there is never a brace in them. + // Ignore this when finding matches for `'. case '\'': if (!cpo_match && initc != '\'' && findc != '\'') { if (backwards) { @@ -2253,10 +2187,8 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel) FALLTHROUGH; default: - /* - * For Lisp skip over backslashed (), {} and []. - * (actually, we skip #\( et al) - */ + // For Lisp skip over backslashed (), {} and []. + // (actually, we skip #\( et al) if (curbuf->b_p_lisp && vim_strchr("(){}[]", c) != NULL && pos.col > 1 @@ -2322,7 +2254,7 @@ int check_linecomment(const char *line) } } else if (!in_str && ((p - line) < 2 || (*(p - 1) != '\\' && *(p - 2) != '#')) - && !is_pos_in_string((char_u *)line, (colnr_T)(p - line))) { + && !is_pos_in_string(line, (colnr_T)(p - line))) { break; // found! } p++; @@ -2336,7 +2268,7 @@ int check_linecomment(const char *line) // because * / / * is an end and start of a C comment. Only // accept the position if it is not inside a string. if (p[1] == '/' && (p == line || p[-1] != '*' || p[2] != '*') - && !is_pos_in_string((char_u *)line, (colnr_T)(p - line))) { + && !is_pos_in_string(line, (colnr_T)(p - line))) { break; } p++; @@ -2366,21 +2298,19 @@ void showmatch(int c) long save_siso; int save_state; colnr_T save_dollar_vcol; - char_u *p; + char *p; - /* - * Only show match for chars in the 'matchpairs' option. - */ + // Only show match for chars in the 'matchpairs' option. // 'matchpairs' is "x:y,x:y" - for (p = (char_u *)curbuf->b_p_mps; *p != NUL; p++) { - if (utf_ptr2char((char *)p) == c && (curwin->w_p_rl ^ p_ri)) { + for (p = curbuf->b_p_mps; *p != NUL; p++) { + if (utf_ptr2char(p) == c && (curwin->w_p_rl ^ p_ri)) { break; } - p += utfc_ptr2len((char *)p) + 1; - if (utf_ptr2char((char *)p) == c && !(curwin->w_p_rl ^ p_ri)) { + p += utfc_ptr2len(p) + 1; + if (utf_ptr2char(p) == c && !(curwin->w_p_rl ^ p_ri)) { break; } - p += utfc_ptr2len((char *)p); + p += utfc_ptr2len(p); if (*p == NUL) { return; } @@ -2409,7 +2339,7 @@ void showmatch(int c) dollar_vcol = -1; } curwin->w_virtcol++; // do display ')' just before "$" - update_screen(UPD_VALID); // show the new char first + update_screen(); // show the new char first save_dollar_vcol = dollar_vcol; save_state = State; @@ -2426,10 +2356,8 @@ void showmatch(int c) // and has a higher column number. dollar_vcol = save_dollar_vcol; - /* - * brief pause, unless 'm' is present in 'cpo' and a character is - * available. - */ + // brief pause, unless 'm' is present in 'cpo' and a character is + // available. if (vim_strchr(p_cpo, CPO_SHOWMATCH) != NULL) { os_delay((uint64_t)p_mat * 100L + 8, true); } else if (!char_avail()) { @@ -2479,8 +2407,7 @@ int current_search(long count, bool forward) } // Is the pattern is zero-width?, this time, don't care about the direction - int zero_width = is_zero_width(spats[last_idx].pat, true, &curwin->w_cursor, - FORWARD); + int zero_width = is_zero_width(spats[last_idx].pat, true, &curwin->w_cursor, FORWARD); if (zero_width == -1) { return FAIL; // pattern not found } @@ -2513,7 +2440,7 @@ int current_search(long count, bool forward) result = searchit(curwin, curbuf, &pos, &end_pos, (dir ? FORWARD : BACKWARD), - spats[last_idx].pat, i ? count : 1, + (char_u *)spats[last_idx].pat, i ? count : 1, SEARCH_KEEP | flags, RE_SEARCH, NULL); p_ws = old_p_ws; @@ -2534,7 +2461,7 @@ int current_search(long count, bool forward) } else { // 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)); + pos.col = (colnr_T)strlen(ml_get(curwin->w_buffer->b_ml.ml_line_count)); } } } @@ -2587,7 +2514,7 @@ int current_search(long count, bool forward) /// else from position "cur". /// "direction" is FORWARD or BACKWARD. /// Returns true, false or -1 for failure. -static int is_zero_width(char_u *pattern, int move, pos_T *cur, Direction direction) +static int is_zero_width(char *pattern, int move, pos_T *cur, Direction direction) { regmmatch_T regmatch; int nmatched = 0; @@ -2600,7 +2527,7 @@ static int is_zero_width(char_u *pattern, int move, pos_T *cur, Direction direct pattern = spats[last_idx].pat; } - if (search_regcomp(pattern, RE_SEARCH, RE_SEARCH, + if (search_regcomp((char_u *)pattern, NULL, RE_SEARCH, RE_SEARCH, SEARCH_KEEP, ®match) == FAIL) { return -1; } @@ -2615,7 +2542,7 @@ static int is_zero_width(char_u *pattern, int move, pos_T *cur, Direction direct // accept a match at the cursor position flag = SEARCH_START; } - if (searchit(curwin, curbuf, &pos, NULL, direction, pattern, 1, + if (searchit(curwin, curbuf, &pos, NULL, direction, (char_u *)pattern, 1, SEARCH_KEEP + flag, RE_SEARCH, NULL) != FAIL) { // Zero-width pattern should match somewhere, then we can check if // start and end are in the same position. @@ -2646,16 +2573,16 @@ static int is_zero_width(char_u *pattern, int move, pos_T *cur, Direction direct /// return true if line 'lnum' is empty or has white chars only. int linewhite(linenr_T lnum) { - char_u *p; + char *p; - p = (char_u *)skipwhite((char *)ml_get(lnum)); + p = skipwhite(ml_get(lnum)); return *p == NUL; } -// Add the search count "[3/19]" to "msgbuf". -// See update_search_stat() for other arguments. +/// Add the search count "[3/19]" to "msgbuf". +/// See update_search_stat() for other arguments. static void cmdline_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, bool show_top_bot_msg, - char_u *msgbuf, bool recompute, int maxcount, long timeout) + char *msgbuf, bool recompute, int maxcount, long timeout) { searchstat_T stat; @@ -2700,7 +2627,7 @@ static void cmdline_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, bool sh len += 2; } - memmove(msgbuf + STRLEN(msgbuf) - len, t, len); + memmove(msgbuf + strlen(msgbuf) - len, t, len); if (dirc == '?' && stat.cur == maxcount + 1) { stat.cur = -1; } @@ -2708,7 +2635,7 @@ static void cmdline_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, bool sh // keep the message even after redraw, but don't put in history msg_hist_off = true; msg_ext_set_kind("search_count"); - give_warning((char *)msgbuf, false); + give_warning(msgbuf, false); msg_hist_off = false; } } @@ -2732,7 +2659,7 @@ static void update_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, searchst static int incomplete = 0; static int last_maxcount = SEARCH_STAT_DEF_MAX_COUNT; static int chgtick = 0; - static char_u *lastpat = NULL; + static char *lastpat = NULL; static buf_T *lbuf = NULL; proftime_T start; @@ -2756,8 +2683,8 @@ static void update_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, searchst // XXX: above comment should be "no MB_STRCMP function" ? if (!(chgtick == buf_get_changedtick(curbuf) && lastpat != NULL // suppress clang/NULL passed as nonnull parameter - && STRNICMP(lastpat, spats[last_idx].pat, STRLEN(lastpat)) == 0 - && STRLEN(lastpat) == STRLEN(spats[last_idx].pat) + && STRNICMP(lastpat, spats[last_idx].pat, strlen(lastpat)) == 0 + && strlen(lastpat) == strlen(spats[last_idx].pat) && equalpos(lastpos, *cursor_pos) && lbuf == curbuf) || wraparound || cur < 0 || (maxcount > 0 && cur > maxcount) @@ -2807,7 +2734,7 @@ static void update_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, searchst } if (done_search) { xfree(lastpat); - lastpat = vim_strsave(spats[last_idx].pat); + lastpat = xstrdup(spats[last_idx].pat); chgtick = (int)buf_get_changedtick(curbuf); lbuf = curbuf; lastpos = p; @@ -2825,7 +2752,7 @@ static void update_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, searchst void f_searchcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) { pos_T pos = curwin->w_cursor; - char_u *pattern = NULL; + char *pattern = NULL; int maxcount = SEARCH_STAT_DEF_MAX_COUNT; long timeout = SEARCH_STAT_DEF_TIMEOUT; bool recompute = true; @@ -2869,9 +2796,9 @@ void f_searchcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) return; } } - di = tv_dict_find(dict, (const char *)"pattern", -1); + di = tv_dict_find(dict, "pattern", -1); if (di != NULL) { - pattern = (char_u *)tv_get_string_chk(&di->di_tv); + pattern = (char *)tv_get_string_chk(&di->di_tv); if (pattern == NULL) { return; } @@ -2917,7 +2844,7 @@ void f_searchcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) goto the_end; } xfree(spats[last_idx].pat); - spats[last_idx].pat = vim_strsave(pattern); + spats[last_idx].pat = xstrdup(pattern); } if (spats[last_idx].pat == NULL || *spats[last_idx].pat == NUL) { goto the_end; // the previous pattern was never defined @@ -3016,7 +2943,7 @@ typedef struct { /// Compute a score for a fuzzy matched string. The matching character locations /// are in 'matches'. -static int fuzzy_match_compute_score(const char_u *const str, const int strSz, +static int fuzzy_match_compute_score(const char *const str, const int strSz, const uint32_t *const matches, const int numMatches) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE { @@ -3053,14 +2980,14 @@ static int fuzzy_match_compute_score(const char_u *const str, const int strSz, // Check for bonuses based on neighbor character value if (currIdx > 0) { // Camel case - const char_u *p = str; + const char *p = str; int neighbor = ' '; for (uint32_t sidx = 0; sidx < currIdx; sidx++) { - neighbor = utf_ptr2char((char *)p); + neighbor = utf_ptr2char(p); MB_PTR_ADV(p); } - const int curr = utf_ptr2char((char *)p); + const int curr = utf_ptr2char(p); if (mb_islower(neighbor) && mb_isupper(curr)) { score += CAMEL_BONUS; @@ -3082,11 +3009,10 @@ static int fuzzy_match_compute_score(const char_u *const str, const int strSz, /// Perform a recursive search for fuzzy matching 'fuzpat' in 'str'. /// @return the number of matching characters. -static int fuzzy_match_recursive(const char_u *fuzpat, const char_u *str, uint32_t strIdx, - int *const outScore, const char_u *const strBegin, - const int strLen, const uint32_t *const srcMatches, - uint32_t *const matches, const int maxMatches, int nextMatch, - int *const recursionCount) +static int fuzzy_match_recursive(const char *fuzpat, const char *str, uint32_t strIdx, + int *const outScore, const char *const strBegin, const int strLen, + const uint32_t *const srcMatches, uint32_t *const matches, + const int maxMatches, int nextMatch, int *const recursionCount) FUNC_ATTR_NONNULL_ARG(1, 2, 4, 5, 8, 11) FUNC_ATTR_WARN_UNUSED_RESULT { // Recursion params @@ -3127,7 +3053,7 @@ static int fuzzy_match_recursive(const char_u *fuzpat, const char_u *str, uint32 // Recursive call that "skips" this match uint32_t recursiveMatches[MAX_FUZZY_MATCHES]; int recursiveScore = 0; - const char_u *const next_char = str + utfc_ptr2len((char *)str); + const char *const next_char = (char *)str + utfc_ptr2len((char *)str); if (fuzzy_match_recursive(fuzpat, next_char, strIdx + 1, &recursiveScore, strBegin, strLen, matches, recursiveMatches, sizeof(recursiveMatches) / sizeof(recursiveMatches[0]), nextMatch, @@ -3187,15 +3113,15 @@ bool fuzzy_match(char_u *const str, const char_u *const pat_arg, const bool matc int *const outScore, uint32_t *const matches, const int maxMatches) FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT { - const int len = mb_charlen(str); + const int len = mb_charlen((char *)str); bool complete = false; int numMatches = 0; *outScore = 0; - char_u *const save_pat = vim_strsave(pat_arg); - char_u *pat = save_pat; - char_u *p = pat; + char *const save_pat = xstrdup((char *)pat_arg); + char *pat = save_pat; + char *p = pat; // Try matching each word in 'pat_arg' in 'str' while (true) { @@ -3203,12 +3129,12 @@ bool fuzzy_match(char_u *const str, const char_u *const pat_arg, const bool matc complete = true; } else { // Extract one word from the pattern (separated by space) - p = (char_u *)skipwhite((char *)p); + p = skipwhite(p); if (*p == NUL) { break; } pat = p; - while (*p != NUL && !ascii_iswhite(utf_ptr2char((char *)p))) { + while (*p != NUL && !ascii_iswhite(utf_ptr2char(p))) { MB_PTR_ADV(p); } if (*p == NUL) { // processed all the words @@ -3220,7 +3146,8 @@ bool fuzzy_match(char_u *const str, const char_u *const pat_arg, const bool matc int score = 0; int recursionCount = 0; const int matchCount - = fuzzy_match_recursive(pat, str, 0, &score, str, len, NULL, matches + numMatches, + = fuzzy_match_recursive(pat, (char *)str, 0, &score, (char *)str, len, NULL, + matches + numMatches, maxMatches - numMatches, 0, &recursionCount); if (matchCount == 0) { numMatches = 0; @@ -3265,8 +3192,8 @@ static int fuzzy_match_item_compare(const void *const s1, const void *const s2) /// for each item or use 'item_cb' Funcref function to get the string. /// If 'retmatchpos' is true, then return a list of positions where 'str' /// matches for each item. -static void fuzzy_match_in_list(list_T *const l, char_u *const str, const bool matchseq, - const char_u *const key, Callback *const item_cb, +static void fuzzy_match_in_list(list_T *const l, char *const str, const bool matchseq, + const char *const key, Callback *const item_cb, const bool retmatchpos, list_T *const fmatchlist, const long max_matches) FUNC_ATTR_NONNULL_ARG(2, 5, 7) @@ -3289,17 +3216,17 @@ static void fuzzy_match_in_list(list_T *const l, char_u *const str, const bool m break; } - char_u *itemstr = NULL; + char *itemstr = NULL; typval_T rettv; rettv.v_type = VAR_UNKNOWN; const typval_T *const tv = TV_LIST_ITEM_TV(li); if (tv->v_type == VAR_STRING) { // list of strings - itemstr = (char_u *)tv->vval.v_string; + itemstr = tv->vval.v_string; } else if (tv->v_type == VAR_DICT && (key != NULL || item_cb->type != kCallbackNone)) { // For a dict, either use the specified key to lookup the string or // use the specified callback function to get the string. if (key != NULL) { - itemstr = (char_u *)tv_dict_get_string(tv->vval.v_dict, (const char *)key, false); + itemstr = tv_dict_get_string(tv->vval.v_dict, (const char *)key, false); } else { typval_T argv[2]; @@ -3310,7 +3237,7 @@ static void fuzzy_match_in_list(list_T *const l, char_u *const str, const bool m argv[1].v_type = VAR_UNKNOWN; if (callback_call(item_cb, 1, argv, &rettv)) { if (rettv.v_type == VAR_STRING) { - itemstr = (char_u *)rettv.vval.v_string; + itemstr = rettv.vval.v_string; } } tv_dict_unref(tv->vval.v_dict); @@ -3318,7 +3245,7 @@ static void fuzzy_match_in_list(list_T *const l, char_u *const str, const bool m } int score; - if (itemstr != NULL && fuzzy_match(itemstr, str, matchseq, &score, matches, + if (itemstr != NULL && fuzzy_match((char_u *)itemstr, (char_u *)str, matchseq, &score, matches, MAX_FUZZY_MATCHES)) { items[match_count].idx = (int)match_count; items[match_count].item = li; @@ -3329,9 +3256,9 @@ static void fuzzy_match_in_list(list_T *const l, char_u *const str, const bool m if (retmatchpos) { items[match_count].lmatchpos = tv_list_alloc(kListLenMayKnow); int j = 0; - const char_u *p = str; + const char *p = (char *)str; while (*p != NUL) { - if (!ascii_iswhite(utf_ptr2char((char *)p)) || matchseq) { + if (!ascii_iswhite(utf_ptr2char(p)) || matchseq) { tv_list_append_number(items[match_count].lmatchpos, matches[j]); j++; } @@ -3416,7 +3343,7 @@ static void do_fuzzymatch(const typval_T *const argvars, typval_T *const rettv, } Callback cb = CALLBACK_NONE; - const char_u *key = NULL; + const char *key = NULL; bool matchseq = false; long max_matches = 0; if (argvars[2].v_type != VAR_UNKNOWN) { @@ -3435,7 +3362,7 @@ static void do_fuzzymatch(const typval_T *const argvars, typval_T *const rettv, semsg(_(e_invarg2), tv_get_string(&di->di_tv)); return; } - key = (const char_u *)tv_get_string(&di->di_tv); + key = tv_get_string(&di->di_tv); } else if (!tv_dict_get_callback(d, "text_cb", -1, &cb)) { semsg(_(e_invargval), "text_cb"); return; @@ -3466,7 +3393,8 @@ static void do_fuzzymatch(const typval_T *const argvars, typval_T *const rettv, tv_list_append_list(rettv->vval.v_list, tv_list_alloc(kListLenUnknown)); } - fuzzy_match_in_list(argvars[0].vval.v_list, (char_u *)tv_get_string(&argvars[1]), matchseq, key, + fuzzy_match_in_list(argvars[0].vval.v_list, + (char *)tv_get_string(&argvars[1]), matchseq, key, &cb, retmatchpos, rettv->vval.v_list, max_matches); callback_free(&cb); } @@ -3486,10 +3414,10 @@ void f_matchfuzzypos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) /// Get line "lnum" and copy it into "buf[LSIZE]". /// The copy is made because the regexp may make the line invalid when using a /// mark. -static char_u *get_line_and_copy(linenr_T lnum, char_u *buf) +static char *get_line_and_copy(linenr_T lnum, char *buf) { - char_u *line = ml_get(lnum); - STRLCPY(buf, line, LSIZE); + char *line = ml_get(lnum); + xstrlcpy(buf, line, LSIZE); return buf; } @@ -3505,7 +3433,7 @@ static char_u *get_line_and_copy(linenr_T lnum, char_u *buf) /// @param action What to do when we find it /// @param start_lnum first line to start searching /// @param end_lnum last line for searching -void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bool skip_comments, +void find_pattern_in_path(char *ptr, Direction dir, size_t len, bool whole, bool skip_comments, int type, long count, int action, linenr_T start_lnum, linenr_T end_lnum) { SearchedFile *files; // Stack of included files @@ -3513,19 +3441,19 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo int max_path_depth = 50; long match_count = 1; - char_u *pat; - char_u *new_fname; - char_u *curr_fname = (char_u *)curbuf->b_fname; - char_u *prev_fname = NULL; + char *pat; + char *new_fname; + char *curr_fname = curbuf->b_fname; + char *prev_fname = NULL; linenr_T lnum; int depth; int depth_displayed; // For type==CHECK_PATH int old_files; int already_searched; - char_u *file_line; - char_u *line; - char_u *p; - char_u save_char; + char *file_line; + char *line; + char *p; + char save_char; bool define_matched; regmatch_T regmatch; regmatch_T incl_regmatch; @@ -3534,8 +3462,8 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo bool did_show = false; bool found = false; int i; - char_u *already = NULL; - char_u *startp = NULL; + char *already = NULL; + char *startp = NULL; win_T *curwin_save = NULL; const int l_g_do_tagpreview = g_do_tagpreview; @@ -3549,12 +3477,13 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo // when CONT_SOL is set compare "ptr" with the beginning of the // line is faster than quote_meta/regcomp/regexec "ptr" -- Acevedo && !compl_status_sol()) { - pat = xmalloc(len + 5); + size_t patlen = len + 5; + pat = xmalloc(patlen); assert(len <= INT_MAX); - sprintf((char *)pat, whole ? "\\<%.*s\\>" : "%.*s", (int)len, ptr); + snprintf(pat, patlen, whole ? "\\<%.*s\\>" : "%.*s", (int)len, ptr); // ignore case according to p_ic, p_scs and pat regmatch.rm_ic = ignorecase(pat); - regmatch.regprog = vim_regcomp((char *)pat, p_magic ? RE_MAGIC : 0); + regmatch.regprog = vim_regcomp(pat, magic_isset() ? RE_MAGIC : 0); xfree(pat); if (regmatch.regprog == NULL) { goto fpip_end; @@ -3562,7 +3491,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo } char *inc_opt = (*curbuf->b_p_inc == NUL) ? p_inc : curbuf->b_p_inc; if (*inc_opt != NUL) { - incl_regmatch.regprog = vim_regcomp(inc_opt, p_magic ? RE_MAGIC : 0); + incl_regmatch.regprog = vim_regcomp(inc_opt, magic_isset() ? RE_MAGIC : 0); if (incl_regmatch.regprog == NULL) { goto fpip_end; } @@ -3571,7 +3500,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo if (type == FIND_DEFINE && (*curbuf->b_p_def != NUL || *p_def != NUL)) { def_regmatch.regprog = vim_regcomp(*curbuf->b_p_def == NUL ? p_def : curbuf->b_p_def, - p_magic ? RE_MAGIC : 0); + magic_isset() ? RE_MAGIC : 0); if (def_regmatch.regprog == NULL) { goto fpip_end; } @@ -3592,9 +3521,9 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo for (;;) { if (incl_regmatch.regprog != NULL - && vim_regexec(&incl_regmatch, (char *)line, (colnr_T)0)) { - char_u *p_fname = (curr_fname == (char_u *)curbuf->b_fname) - ? (char_u *)curbuf->b_ffname : curr_fname; + && vim_regexec(&incl_regmatch, line, (colnr_T)0)) { + char *p_fname = (curr_fname == curbuf->b_fname) + ? curbuf->b_ffname : curr_fname; if (inc_opt != NULL && strstr(inc_opt, "\\zs") != NULL) { // Use text from '\zs' to '\ze' (or end) of 'include'. @@ -3605,8 +3534,9 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo 1L, p_fname); } else { // 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); + new_fname = (char *)file_name_in_line((char_u *)incl_regmatch.endp[0], 0, + FNAME_EXP|FNAME_INCL|FNAME_REL, 1L, (char_u *)p_fname, + NULL); } already_searched = false; if (new_fname != NULL) { @@ -3618,7 +3548,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo if (i == max_path_depth) { break; } - if (path_full_compare((char *)new_fname, (char *)files[i].name, true, + if (path_full_compare(new_fname, files[i].name, true, true) & kEqualFiles) { if (type != CHECK_PATH && action == ACTION_SHOW_ALL && files[i].matched) { @@ -3666,12 +3596,10 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo if (new_fname != NULL) { // using "new_fname" is more reliable, e.g., when // 'includeexpr' is set. - msg_outtrans_attr((char *)new_fname, HL_ATTR(HLF_D)); + msg_outtrans_attr(new_fname, HL_ATTR(HLF_D)); } else { - /* - * Isolate the file name. - * Include the surrounding "" or <> if present. - */ + // Isolate the file name. + // Include the surrounding "" or <> if present. if (inc_opt != NULL && strstr(inc_opt, "\\zs") != NULL) { // pattern contains \zs, use the match @@ -3681,14 +3609,14 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo } else { // find the file name after the end of the match for (p = incl_regmatch.endp[0]; - *p && !vim_isfilec(*p); p++) {} - for (i = 0; vim_isfilec(p[i]); i++) {} + *p && !vim_isfilec((uint8_t)(*p)); p++) {} + for (i = 0; vim_isfilec((uint8_t)p[i]); i++) {} } if (i == 0) { // Nothing found, use the rest of the line. p = incl_regmatch.endp[0]; - i = (int)STRLEN(p); + i = (int)strlen(p); } else if (p > line) { // Avoid checking before the start of the line, can // happen if \zs appears in the regexp. @@ -3702,7 +3630,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo } save_char = p[i]; p[i] = NUL; - msg_outtrans_attr((char *)p, HL_ATTR(HLF_D)); + msg_outtrans_attr(p, HL_ATTR(HLF_D)); p[i] = save_char; } @@ -3714,7 +3642,6 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo } } } - ui_flush(); // output each line directly } if (new_fname != NULL) { @@ -3738,7 +3665,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo xfree(files); files = bigger; } - if ((files[depth + 1].fp = os_fopen((char *)new_fname, "r")) == NULL) { + if ((files[depth + 1].fp = os_fopen(new_fname, "r")) == NULL) { xfree(new_fname); } else { if (++depth == old_files) { @@ -3752,56 +3679,51 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo files[depth].matched = false; if (action == ACTION_EXPAND) { msg_hist_off = true; // reset in msg_trunc_attr() - vim_snprintf((char *)IObuff, IOSIZE, + vim_snprintf(IObuff, IOSIZE, _("Scanning included file: %s"), - (char *)new_fname); - msg_trunc_attr((char *)IObuff, true, HL_ATTR(HLF_R)); + new_fname); + msg_trunc_attr(IObuff, true, HL_ATTR(HLF_R)); } else if (p_verbose >= 5) { verbose_enter(); - smsg(_("Searching included file %s"), - (char *)new_fname); + smsg(_("Searching included file %s"), new_fname); verbose_leave(); } } } } else { - /* - * Check if the line is a define (type == FIND_DEFINE) - */ + // Check if the line is a define (type == FIND_DEFINE) p = line; search_line: define_matched = false; if (def_regmatch.regprog != NULL - && vim_regexec(&def_regmatch, (char *)line, (colnr_T)0)) { + && vim_regexec(&def_regmatch, line, (colnr_T)0)) { // Pattern must be first identifier after 'define', so skip // to that position before checking for match of pattern. Also // don't let it match beyond the end of this identifier. p = def_regmatch.endp[0]; - while (*p && !vim_iswordc(*p)) { + while (*p && !vim_iswordc((uint8_t)(*p))) { p++; } define_matched = true; } - /* - * Look for a match. Don't do this if we are looking for a - * define and this line didn't match define_prog above. - */ + // Look for a match. Don't do this if we are looking for a + // define and this line didn't match define_prog above. if (def_regmatch.regprog == NULL || define_matched) { if (define_matched || compl_status_sol()) { // compare the first "len" chars from "ptr" - startp = (char_u *)skipwhite((char *)p); + startp = skipwhite(p); if (p_ic) { matched = !mb_strnicmp(startp, ptr, len); } else { - matched = !STRNCMP(startp, ptr, len); + matched = !strncmp(startp, ptr, len); } if (matched && define_matched && whole - && vim_iswordc(startp[len])) { + && vim_iswordc((uint8_t)startp[len])) { matched = false; } } else if (regmatch.regprog != NULL - && vim_regexec(®match, (char *)line, (colnr_T)(p - line))) { + && vim_regexec(®match, line, (colnr_T)(p - line))) { matched = true; startp = regmatch.startp[0]; // Check if the line is not a comment line (unless we are @@ -3809,18 +3731,16 @@ search_line: // is not considered to be a comment line. if (skip_comments) { if ((*line != '#' - || STRNCMP(skipwhite((char *)line + 1), "define", 6) != 0) - && get_leader_len((char *)line, NULL, false, true)) { + || strncmp(skipwhite(line + 1), "define", 6) != 0) + && get_leader_len(line, NULL, false, true)) { matched = false; } - /* - * Also check for a "/ *" or "/ /" before the match. - * Skips lines like "int backwards; / * normal index - * * /" when looking for "normal". - * Note: Doesn't skip "/ *" in comments. - */ - p = (char_u *)skipwhite((char *)line); + // Also check for a "/ *" or "/ /" before the match. + // Skips lines like "int backwards; / * normal index + // * /" when looking for "normal". + // Note: Doesn't skip "/ *" in comments. + p = skipwhite(line); if (matched || (p[0] == '/' && p[1] == '*') || p[0] == '*') { for (p = line; *p && p < startp; p++) { @@ -3847,13 +3767,12 @@ search_line: if (matched) { if (action == ACTION_EXPAND) { bool cont_s_ipos = false; - char_u *aux; if (depth == -1 && lnum == curwin->w_cursor.lnum) { break; } found = true; - aux = p = startp; + char *aux = p = startp; if (compl_status_adding()) { p += ins_compl_len(); if (vim_iswordp(p)) { @@ -3865,8 +3784,8 @@ search_line: i = (int)(p - aux); if (compl_status_adding() && i == ins_compl_len()) { - // IOSIZE > compl_length, so the STRNCPY works - STRNCPY(IObuff, aux, i); + // IOSIZE > compl_length, so the strncpy works + strncpy(IObuff, aux, (size_t)i); // NOLINT(runtime/printf) // Get the next line: when "depth" < 0 from the current // buffer, otherwise from the included file. Jump to @@ -3884,7 +3803,7 @@ search_line: // we read a line, set "already" to check this "line" later // if depth >= 0 we'll increase files[depth].lnum far // below -- Acevedo - already = aux = p = (char_u *)skipwhite((char *)line); + already = aux = p = skipwhite(line); p = find_word_start(p); p = find_word_end(p); if (p > aux) { @@ -3904,7 +3823,7 @@ search_line: if (p - aux >= IOSIZE - i) { p = aux + IOSIZE - i - 1; } - STRNCPY(IObuff + i, aux, p - aux); + strncpy(IObuff + i, aux, (size_t)(p - aux)); // NOLINT(runtime/printf) i += (int)(p - aux); cont_s_ipos = true; } @@ -3917,7 +3836,7 @@ search_line: } const int add_r = ins_compl_add_infercase(aux, i, p_ic, - curr_fname == (char_u *)curbuf->b_fname + curr_fname == curbuf->b_fname ? NULL : curr_fname, dir, cont_s_ipos); if (add_r == OK) { @@ -4023,7 +3942,7 @@ exit_matched: && action == ACTION_EXPAND && !compl_status_sol() && *startp != NUL - && *(p = startp + utfc_ptr2len((char *)startp)) != NUL) { + && *(p = startp + utfc_ptr2len(startp)) != NUL) { goto search_line; } } @@ -4035,11 +3954,9 @@ exit_matched: break; } - /* - * Read the next line. When reading an included file and encountering - * end-of-file, close the file and continue in the file that included - * it. - */ + // Read the next line. When reading an included file and encountering + // end-of-file, close the file and continue in the file that included + // it. while (depth >= 0 && !already && vim_fgets(line = file_line, LSIZE, files[depth].fp)) { fclose(files[depth].fp); @@ -4047,7 +3964,7 @@ exit_matched: files[old_files].name = files[depth].name; files[old_files].matched = files[depth].matched; depth--; - curr_fname = (depth == -1) ? (char_u *)curbuf->b_fname + curr_fname = (depth == -1) ? curbuf->b_fname : files[depth].name; if (depth < depth_displayed) { depth_displayed = depth; @@ -4056,7 +3973,7 @@ exit_matched: if (depth >= 0) { // we could read the line files[depth].lnum++; // Remove any CR and LF from the line. - i = (int)STRLEN(line); + i = (int)strlen(line); if (i > 0 && line[i - 1] == '\n') { line[--i] = NUL; } @@ -4112,11 +4029,11 @@ fpip_end: vim_regfree(def_regmatch.regprog); } -static void show_pat_in_path(char_u *line, int type, bool did_show, int action, FILE *fp, +static void show_pat_in_path(char *line, int type, bool did_show, int action, FILE *fp, linenr_T *lnum, long count) FUNC_ATTR_NONNULL_ARG(1, 6) { - char_u *p; + char *p; if (did_show) { msg_putchar('\n'); // cursor below last one @@ -4127,7 +4044,7 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action, return; } for (;;) { - p = line + STRLEN(line) - 1; + p = line + strlen(line) - 1; if (fp != NULL) { // We used fgets(), so get rid of newline at end if (p >= line && *p == '\n') { @@ -4139,15 +4056,14 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action, *(p + 1) = NUL; } if (action == ACTION_SHOW_ALL) { - snprintf((char *)IObuff, IOSIZE, "%3ld: ", count); // Show match nr. + snprintf(IObuff, IOSIZE, "%3ld: ", count); // Show match nr. msg_puts((const char *)IObuff); - snprintf((char *)IObuff, IOSIZE, "%4" PRIdLINENR, *lnum); // Show line nr. + snprintf(IObuff, IOSIZE, "%4" PRIdLINENR, *lnum); // Show line nr. // Highlight line numbers. msg_puts_attr((const char *)IObuff, HL_ATTR(HLF_N)); msg_puts(" "); } msg_prt_line(line, false); - ui_flush(); // show one line at a time // Definition continues until line that doesn't end with '\' if (got_int || type != FIND_DEFINE || p < line || *p != '\\') { @@ -4158,7 +4074,7 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action, if (vim_fgets(line, LSIZE, fp)) { // end of file break; } - ++*lnum; + (*lnum)++; } else { if (++*lnum > curbuf->b_ml.ml_line_count) { break; |