Mercurial > vim
view src/search.c @ 15711:287104a1d51e v8.1.0863
patch 8.1.0863: cannot see what signal caused a job to end
commit https://github.com/vim/vim/commit/b3051ce82f2e8af95ce3b6a41867f70aee5ecc82
Author: Bram Moolenaar <Bram@vim.org>
Date: Thu Jan 31 15:52:11 2019 +0100
patch 8.1.0863: cannot see what signal caused a job to end
Problem: Cannot see what signal caused a job to end.
Solution: Add "termsig" to job_info(). (Ozaki Kiichi, closes https://github.com/vim/vim/issues/3786)
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Thu, 31 Jan 2019 16:00:06 +0100 |
parents | 6f1c7e9a6393 |
children | ad8b2c109b22 |
line wrap: on
line source
/* vi:set ts=8 sts=4 sw=4 noet: * * VIM - Vi IMproved by Bram Moolenaar * * Do ":help uganda" in Vim to read copying and usage conditions. * Do ":help credits" in Vim to see a list of people who contributed. * See README.txt for an overview of the Vim source code. */ /* * search.c: code for normal mode searching commands */ #include "vim.h" #ifdef FEAT_EVAL static void set_vv_searchforward(void); static int first_submatch(regmmatch_T *rp); #endif static int check_linecomment(char_u *line); static int cls(void); static int skip_chars(int, int); #ifdef FEAT_FIND_ID static void show_pat_in_path(char_u *, int, int, int, FILE *, linenr_T *, long); #endif #ifdef FEAT_VIMINFO static void wvsp_one(FILE *fp, int idx, char *s, int sc); #endif /* * This file contains various searching-related routines. These fall into * three groups: * 1. string searches (for /, ?, n, and N) * 2. character searches within a single line (for f, F, t, T, etc) * 3. "other" kinds of searches like the '%' command, and 'word' searches. */ /* * String searches * * The string search functions are divided into two levels: * lowest: searchit(); uses an pos_T for starting position and found match. * Highest: do_search(); uses curwin->w_cursor; calls searchit(). * * The last search pattern is remembered for repeating the same search. * This pattern is shared between the :g, :s, ? and / commands. * This is in search_regcomp(). * * The actual string matching is done using a heavily modified version of * Henry Spencer's regular expression library. See regexp.c. */ /* The offset for a search command is store in a soff struct */ /* Note: only spats[0].off is really used */ struct soffset { int dir; /* search direction, '/' or '?' */ int line; /* search has line offset */ int end; /* search set cursor at end */ long off; /* line or char offset */ }; /* A search pattern and its attributes are stored in a spat struct */ struct spat { char_u *pat; /* the pattern (in allocated memory) or NULL */ int magic; /* magicness of the pattern */ int no_scs; /* no smartcase for this pattern */ struct soffset off; }; /* * Two search patterns are remembered: One for the :substitute command and * one for other searches. last_idx points to the one that was used the last * time. */ static struct spat spats[2] = { {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 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 */ /* copy of spats[], for keeping the search patterns while executing autocmds */ static struct spat 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() */ #ifdef FEAT_RIGHTLEFT static int mr_pattern_alloced = FALSE; /* mr_pattern was allocated */ #endif #ifdef FEAT_FIND_ID /* * 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 */ linenr_T lnum; /* Line we were up to in file */ int matched; /* Found a match in this file */ } SearchedFile; #endif /* * translate search pattern for vim_regcomp() * * pat_save == RE_SEARCH: save pat in spats[RE_SEARCH].pat (normal search cmd) * pat_save == RE_SUBST: save pat in spats[RE_SUBST].pat (:substitute command) * pat_save == RE_BOTH: save pat in both patterns (:global command) * pat_use == RE_SEARCH: use previous search pattern if "pat" is NULL * pat_use == RE_SUBST: use previous substitute pattern if "pat" is NULL * pat_use == RE_LAST: use last used pattern if "pat" is NULL * options & SEARCH_HIS: put search string in history * options & SEARCH_KEEP: keep previous search pattern * * returns FAIL if failed, OK otherwise. */ int search_regcomp( char_u *pat, int pat_save, int pat_use, int options, regmmatch_T *regmatch) /* return: pattern and ignore-case flag */ { int magic; int i; rc_did_emsg = FALSE; magic = p_magic; /* * If no pattern given, use a previously defined pattern. */ if (pat == NULL || *pat == NUL) { if (pat_use == RE_LAST) i = last_idx; else i = pat_use; if (spats[i].pat == NULL) /* pattern was never defined */ { if (pat_use == RE_SUBST) emsg(_(e_nopresub)); else emsg(_(e_noprevre)); rc_did_emsg = TRUE; return FAIL; } pat = spats[i].pat; magic = spats[i].magic; no_smartcase = spats[i].no_scs; } #ifdef FEAT_CMDHIST else if (options & SEARCH_HIS) /* put new pattern in history */ add_to_history(HIST_SEARCH, pat, TRUE, NUL); #endif #ifdef FEAT_RIGHTLEFT if (mr_pattern_alloced) { vim_free(mr_pattern); mr_pattern_alloced = FALSE; } if (curwin->w_p_rl && *curwin->w_p_rlc == 's') { char_u *rev_pattern; rev_pattern = reverse_text(pat); if (rev_pattern == NULL) mr_pattern = pat; /* out of memory, keep normal pattern. */ else { mr_pattern = rev_pattern; mr_pattern_alloced = TRUE; } } else #endif mr_pattern = pat; /* * Save the currently used pattern in the appropriate place, * unless the pattern should not be remembered. */ if (!(options & SEARCH_KEEP) && !cmdmod.keeppatterns) { /* search or global command */ if (pat_save == RE_SEARCH || pat_save == RE_BOTH) save_re_pat(RE_SEARCH, pat, magic); /* substitute or global command */ if (pat_save == RE_SUBST || pat_save == RE_BOTH) save_re_pat(RE_SUBST, pat, magic); } regmatch->rmm_ic = ignorecase(pat); regmatch->rmm_maxcol = 0; regmatch->regprog = vim_regcomp(pat, magic ? RE_MAGIC : 0); if (regmatch->regprog == NULL) return FAIL; return OK; } /* * Get search pattern used by search_regcomp(). */ char_u * get_search_pat(void) { return mr_pattern; } #if defined(FEAT_RIGHTLEFT) || defined(PROTO) /* * Reverse text into allocated memory. * Returns the allocated string, NULL when out of memory. */ char_u * reverse_text(char_u *s) { unsigned len; unsigned s_i, rev_i; char_u *rev; /* * Reverse the pattern. */ len = (unsigned)STRLEN(s); rev = alloc(len + 1); if (rev != NULL) { rev_i = len; for (s_i = 0; s_i < len; ++s_i) { if (has_mbyte) { int mb_len; mb_len = (*mb_ptr2len)(s + s_i); rev_i -= mb_len; mch_memmove(rev + rev_i, s + s_i, mb_len); s_i += mb_len - 1; } else rev[--rev_i] = s[s_i]; } rev[len] = NUL; } return rev; } #endif void save_re_pat(int idx, char_u *pat, int magic) { if (spats[idx].pat != pat) { vim_free(spats[idx].pat); spats[idx].pat = vim_strsave(pat); spats[idx].magic = magic; spats[idx].no_scs = no_smartcase; last_idx = idx; #ifdef FEAT_SEARCH_EXTRA /* If 'hlsearch' set and search pat changed: need redraw. */ if (p_hls) redraw_all_later(SOME_VALID); set_no_hlsearch(FALSE); #endif } } /* * 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) { 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[1] = spats[1]; if (spats[1].pat != NULL) saved_spats[1].pat = vim_strsave(spats[1].pat); #ifdef FEAT_SEARCH_EXTRA saved_spats_last_idx = last_idx; saved_spats_no_hlsearch = no_hlsearch; #endif } } void restore_search_patterns(void) { if (--save_level == 0) { vim_free(spats[0].pat); spats[0] = saved_spats[0]; #if defined(FEAT_EVAL) set_vv_searchforward(); #endif vim_free(spats[1].pat); spats[1] = saved_spats[1]; #ifdef FEAT_SEARCH_EXTRA last_idx = saved_spats_last_idx; set_no_hlsearch(saved_spats_no_hlsearch); #endif } } #if defined(EXITFREE) || defined(PROTO) void free_search_patterns(void) { vim_free(spats[0].pat); vim_free(spats[1].pat); # ifdef FEAT_RIGHTLEFT if (mr_pattern_alloced) { vim_free(mr_pattern); mr_pattern_alloced = FALSE; mr_pattern = NULL; } # endif } #endif #ifdef FEAT_SEARCH_EXTRA // copy of spats[RE_SEARCH], for keeping the search patterns while incremental // searching static struct spat saved_last_search_spat; static int did_save_last_search_spat = 0; static int saved_last_idx = 0; static int saved_no_hlsearch = 0; /* * Save and restore the search pattern for incremental highlight search * feature. * * It's similar to but different from save_search_patterns() and * restore_search_patterns(), because the search pattern must be restored when * canceling incremental searching even if it's called inside user functions. */ void save_last_search_pattern(void) { if (did_save_last_search_spat != 0) iemsg("did_save_last_search_spat is not zero"); else ++did_save_last_search_spat; 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_idx = last_idx; saved_no_hlsearch = no_hlsearch; } void restore_last_search_pattern(void) { if (did_save_last_search_spat != 1) { iemsg("did_save_last_search_spat is not one"); return; } --did_save_last_search_spat; vim_free(spats[RE_SEARCH].pat); spats[RE_SEARCH] = saved_last_search_spat; saved_last_search_spat.pat = NULL; # if defined(FEAT_EVAL) set_vv_searchforward(); # endif last_idx = saved_last_idx; set_no_hlsearch(saved_no_hlsearch); } char_u * last_search_pattern(void) { return spats[RE_SEARCH].pat; } #endif /* * Return TRUE when case should be ignored for search pattern "pat". * Uses the 'ignorecase' and 'smartcase' options. */ int ignorecase(char_u *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 ic = ic_in; if (ic && !no_smartcase && scs #ifdef FEAT_INS_EXPAND && !(ctrl_x_mode_not_default() && curbuf->b_p_inf) #endif ) ic = !pat_has_uppercase(pat); no_smartcase = FALSE; return ic; } /* * Return TRUE if pattern "pat" has an uppercase character. */ int pat_has_uppercase(char_u *pat) { char_u *p = pat; while (*p != NUL) { int l; if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) { if (enc_utf8 && utf_isupper(utf_ptr2char(p))) return TRUE; p += l; } else if (*p == '\\') { if (p[1] == '_' && p[2] != NUL) /* skip "\_X" */ p += 3; else if (p[1] == '%' && p[2] != NUL) /* skip "\%X" */ p += 3; else if (p[1] != NUL) /* skip "\X" */ p += 2; else p += 1; } else if (MB_ISUPPER(*p)) return TRUE; else ++p; } return FALSE; } #if defined(FEAT_EVAL) || defined(PROTO) char_u * last_csearch(void) { return lastc_bytes; } int last_csearch_forward(void) { return lastcdir == FORWARD; } int last_csearch_until(void) { return last_t_cmd == TRUE; } void set_last_csearch(int c, char_u *s UNUSED, int len UNUSED) { *lastc = c; lastc_bytelen = len; if (len) memcpy(lastc_bytes, s, len); else vim_memset(lastc_bytes, 0, sizeof(lastc_bytes)); } #endif void set_csearch_direction(int cdir) { lastcdir = cdir; } void set_csearch_until(int t_cmd) { last_t_cmd = t_cmd; } char_u * last_search_pat(void) { return spats[last_idx].pat; } /* * Reset search direction to forward. For "gd" and "gD" commands. */ void reset_search_dir(void) { spats[0].off.dir = '/'; #if defined(FEAT_EVAL) set_vv_searchforward(); #endif } #if defined(FEAT_EVAL) || defined(FEAT_VIMINFO) /* * Set the last search pattern. For ":let @/ =" and viminfo. * Also set the saved search pattern, so that this works in an autocommand. */ void set_last_search_pat( char_u *s, int idx, int magic, int setlast) { vim_free(spats[idx].pat); /* An empty string means that nothing should be matched. */ if (*s == NUL) spats[idx].pat = NULL; else spats[idx].pat = vim_strsave(s); spats[idx].magic = magic; spats[idx].no_scs = FALSE; spats[idx].off.dir = '/'; #if defined(FEAT_EVAL) set_vv_searchforward(); #endif spats[idx].off.line = FALSE; spats[idx].off.end = FALSE; spats[idx].off.off = 0; if (setlast) last_idx = idx; if (save_level) { vim_free(saved_spats[idx].pat); saved_spats[idx] = spats[0]; if (spats[idx].pat == NULL) saved_spats[idx].pat = NULL; else saved_spats[idx].pat = vim_strsave(spats[idx].pat); saved_spats_last_idx = last_idx; } # ifdef FEAT_SEARCH_EXTRA /* If 'hlsearch' set and search pat changed: need redraw. */ if (p_hls && idx == last_idx && !no_hlsearch) redraw_all_later(SOME_VALID); # endif } #endif #ifdef FEAT_SEARCH_EXTRA /* * 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) { regmatch->regprog = NULL; return; } ++emsg_off; /* So it doesn't beep if bad expr */ (void)search_regcomp((char_u *)"", 0, last_idx, SEARCH_KEEP, regmatch); --emsg_off; } #endif /* * Lowest level search function. * Search for 'count'th occurrence of pattern "pat" in direction "dir". * Start at position "pos" and return the found position in "pos". * * if (options & SEARCH_MSG) == 0 don't give any messages * if (options & SEARCH_MSG) == SEARCH_NFMSG don't give 'notfound' messages * if (options & SEARCH_MSG) == SEARCH_MSG give all messages * if (options & SEARCH_HIS) put search pattern in history * if (options & SEARCH_END) return position at end of match * if (options & SEARCH_START) accept match at pos itself * if (options & SEARCH_KEEP) keep previous search pattern * if (options & SEARCH_FOLD) match only once in a closed fold * if (options & SEARCH_PEEK) check for typed char, cancel search * if (options & SEARCH_COL) start at pos->col instead of zero * * Return FAIL (zero) for failure, non-zero for success. * When FEAT_EVAL is defined, returns the index of the first matching * subpattern plus one; one if there was none. */ int searchit( win_T *win, /* window to search in; can be NULL for a buffer without a window! */ buf_T *buf, pos_T *pos, pos_T *end_pos, // set to end of the match, unless NULL int dir, char_u *pat, long count, int options, int pat_use, /* which pattern to use when "pat" is empty */ linenr_T stop_lnum, /* stop after this line number when != 0 */ proftime_T *tm UNUSED, /* timeout limit or NULL */ int *timed_out UNUSED) /* set when timed out or NULL */ { int found; linenr_T lnum; /* no init to shut up Apollo cc */ colnr_T col; regmmatch_T regmatch; char_u *ptr; colnr_T matchcol; lpos_T endpos; lpos_T matchpos; int loop; pos_T start_pos; int at_first_line; int extra_col; int start_char_len; int match_ok; long nmatched; int submatch = 0; int first_match = TRUE; int save_called_emsg = called_emsg; #ifdef FEAT_SEARCH_EXTRA int break_loop = FALSE; #endif if (search_regcomp(pat, 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); return FAIL; } /* * find the string */ called_emsg = FALSE; 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. */ if (pos->col == MAXCOL) start_char_len = 0; /* 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) { ptr = ml_get_buf(buf, pos->lnum, FALSE); if ((int)STRLEN(ptr) <= pos->col) start_char_len = 1; else start_char_len = (*mb_ptr2len)(ptr + pos->col); } else start_char_len = 1; if (dir == FORWARD) { if (options & SEARCH_START) extra_col = 0; else extra_col = start_char_len; } else { if (options & SEARCH_START) extra_col = start_char_len; else 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 */ { pos->lnum = 1; pos->col = 0; 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. */ if (dir == BACKWARD && start_pos.col == 0 && (options & SEARCH_START) == 0) { lnum = pos->lnum - 1; at_first_line = FALSE; } else lnum = pos->lnum; 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. */ if (stop_lnum != 0 && (dir == FORWARD ? lnum > stop_lnum : lnum < stop_lnum)) break; #ifdef FEAT_RELTIME /* Stop after passing the "tm" time limit. */ if (tm != NULL && profile_passed_limit(tm)) break; #endif /* * Look for a match somewhere in line "lnum". */ col = at_first_line && (options & SEARCH_COL) ? pos->col : (colnr_T)0; nmatched = vim_regexec_multi(®match, win, buf, lnum, col, #ifdef FEAT_RELTIME tm, timed_out #else NULL, NULL #endif ); /* Abort searching on an error (e.g., out of stack). */ if (called_emsg #ifdef FEAT_RELTIME || (timed_out != NULL && *timed_out) #endif ) break; if (nmatched > 0) { /* 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". */ if (lnum + matchpos.lnum > buf->b_ml.ml_line_count) ptr = (char_u *)""; 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. */ 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 * one back afterwards, compare with that position, * otherwise "/$" will get stuck on end of line. */ while (matchpos.lnum == 0 && ((options & SEARCH_END) && first_match ? (nmatched == 1 && (int)endpos.col - 1 < (int)start_pos.col + extra_col) : ((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 (vim_strchr(p_cpo, CPO_SEARCH) != NULL) { if (nmatched > 1) { /* end is in next line, thus no match in * this line */ match_ok = FALSE; break; } matchcol = endpos.col; /* for empty match: advance one char */ if (matchcol == matchpos.col && ptr[matchcol] != NUL) { if (has_mbyte) matchcol += (*mb_ptr2len)(ptr + matchcol); else ++matchcol; } } else { matchcol = matchpos.col; if (ptr[matchcol] != NUL) { if (has_mbyte) matchcol += (*mb_ptr2len)(ptr + matchcol); else ++matchcol; } } if (matchcol == 0 && (options & SEARCH_START)) break; if (ptr[matchcol] == NUL || (nmatched = vim_regexec_multi(®match, win, buf, lnum + matchpos.lnum, matchcol, #ifdef FEAT_RELTIME tm, timed_out #else NULL, NULL #endif )) == 0) { match_ok = FALSE; break; } matchpos = regmatch.startpos[0]; endpos = regmatch.endpos[0]; # ifdef FEAT_EVAL submatch = first_submatch(®match); # endif /* 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) continue; } 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. */ 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. */ if (loop || ((options & SEARCH_END) ? (lnum + regmatch.endpos[0].lnum < start_pos.lnum || (lnum + regmatch.endpos[0].lnum == start_pos.lnum && (int)regmatch.endpos[0].col - 1 < (int)start_pos.col + extra_col)) : (lnum + regmatch.startpos[0].lnum < start_pos.lnum || (lnum + regmatch.startpos[0].lnum == start_pos.lnum && (int)regmatch.startpos[0].col < (int)start_pos.col + extra_col)))) { match_ok = TRUE; matchpos = regmatch.startpos[0]; endpos = regmatch.endpos[0]; # ifdef FEAT_EVAL submatch = first_submatch(®match); # endif } else break; /* * We found a valid match, now check if there is * another one after it. * 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) break; matchcol = endpos.col; /* for empty match: advance one char */ if (matchcol == matchpos.col && ptr[matchcol] != NUL) { if (has_mbyte) matchcol += (*mb_ptr2len)(ptr + matchcol); else ++matchcol; } } else { /* Stop when the match is in a next line. */ if (matchpos.lnum > 0) break; matchcol = matchpos.col; if (ptr[matchcol] != NUL) { if (has_mbyte) matchcol += (*mb_ptr2len)(ptr + matchcol); else ++matchcol; } } if (ptr[matchcol] == NUL || (nmatched = vim_regexec_multi(®match, win, buf, lnum + matchpos.lnum, matchcol, #ifdef FEAT_RELTIME tm, timed_out #else NULL, NULL #endif )) == 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 (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. */ ptr = ml_get_buf(buf, lnum + matchpos.lnum, FALSE); } /* * If there is only a match after the cursor, skip * this match. */ if (!match_ok) 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. */ 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. */ pos->lnum = lnum + endpos.lnum; pos->col = endpos.col; 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)); } } else { --pos->col; if (has_mbyte && pos->lnum <= buf->b_ml.ml_line_count) { ptr = ml_get_buf(buf, pos->lnum, FALSE); pos->col -= (*mb_head_off)(ptr, ptr + pos->col); } } if (end_pos != NULL) { end_pos->lnum = lnum + matchpos.lnum; end_pos->col = matchpos.col; } } else { pos->lnum = lnum + matchpos.lnum; pos->col = matchpos.col; if (end_pos != NULL) { end_pos->lnum = lnum + endpos.lnum; end_pos->col = endpos.col; } } pos->coladd = 0; if (end_pos != NULL) end_pos->coladd = 0; found = 1; first_match = FALSE; /* 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 */ 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. */ if ((options & SEARCH_PEEK) && ((lnum - pos->lnum) & 0x3f) == 0 && char_avail()) { break_loop = TRUE; break; } #endif if (loop && lnum == start_pos.lnum) break; /* if second loop, stop where started */ } at_first_line = FALSE; /* * Stop the search if wrapscan isn't set, "stop_lnum" is * specified, after an interrupt, after a match and after looping * twice. */ if (!p_ws || stop_lnum != 0 || got_int || called_emsg #ifdef FEAT_RELTIME || (timed_out != NULL && *timed_out) #endif #ifdef FEAT_SEARCH_EXTRA || break_loop #endif || found || loop) break; /* * If 'wrapscan' is set we continue at the other end of the file. * If 'shortmess' does not contain 's', we give a message. * This message is also remembered in keep_msg for when the screen * is redrawn. The keep_msg is cleared whenever another message is * written. */ if (dir == BACKWARD) /* start second loop at the other end */ lnum = buf->b_ml.ml_line_count; else lnum = 1; if (!shortmess(SHM_SEARCH) && (options & SEARCH_MSG)) give_warning((char_u *)_(dir == BACKWARD ? top_bot_msg : bot_top_msg), TRUE); } if (got_int || called_emsg #ifdef FEAT_RELTIME || (timed_out != NULL && *timed_out) #endif #ifdef FEAT_SEARCH_EXTRA || break_loop #endif ) break; } 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 (got_int) emsg(_(e_interr)); else if ((options & SEARCH_MSG) == SEARCH_MSG) { if (p_ws) semsg(_(e_patnotf2), mr_pattern); else if (lnum == 0) semsg(_("E384: search hit TOP without match for: %s"), mr_pattern); else semsg(_("E385: search hit BOTTOM without match for: %s"), mr_pattern); } return FAIL; } /* 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)); if (pos->col > 0) --pos->col; } return submatch + 1; } #ifdef FEAT_EVAL void set_search_direction(int cdir) { spats[0].off.dir = cdir; } static void set_vv_searchforward(void) { set_vim_var_nr(VV_SEARCHFORWARD, (long)(spats[0].off.dir == '/')); } /* * Return the number of the first subpat that matched. * Return zero if none of them matched. */ static int first_submatch(regmmatch_T *rp) { int submatch; for (submatch = 1; ; ++submatch) { if (rp->startpos[submatch].lnum >= 0) break; if (submatch == 9) { submatch = 0; break; } } return submatch; } #endif /* * Highest level string search function. * Search for the 'count'th occurrence of pattern 'pat' in direction 'dirc' * If 'dirc' is 0: use previous dir. * If 'pat' is NULL or empty : use previous string. * If 'options & SEARCH_REV' : go in reverse of previous dir. * If 'options & SEARCH_ECHO': echo the search command and handle options * If 'options & SEARCH_MSG' : may give error message * If 'options & SEARCH_OPT' : interpret optional flags * If 'options & SEARCH_HIS' : put search pattern in history * If 'options & SEARCH_NOOF': don't add offset to position * If 'options & SEARCH_MARK': set previous context mark * If 'options & SEARCH_KEEP': keep previous search pattern * If 'options & SEARCH_START': accept match at curpos itself * If 'options & SEARCH_PEEK': check for typed char, cancel search * * Careful: If spats[0].off.line == TRUE and spats[0].off.off == 0 this * makes the movement linewise without moving the match position. * * Return 0 for failure, 1 for found, 2 for found and line offset added. */ int do_search( oparg_T *oap, /* can be NULL */ int dirc, /* '/' or '?' */ char_u *pat, long count, int options, proftime_T *tm, /* timeout limit or NULL */ int *timed_out) /* flag set on timeout or NULL */ { pos_T pos; /* position of the last match */ char_u *searchstr; struct soffset old_off; int retval; /* Return value */ char_u *p; long c; char_u *dircp; char_u *strcopy = NULL; char_u *ps; /* * 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) */ old_off = spats[0].off; pos = curwin->w_cursor; /* start searching at the cursor position */ /* * Find out the direction of the search. */ if (dirc == 0) dirc = spats[0].off.dir; else { spats[0].off.dir = dirc; #if defined(FEAT_EVAL) set_vv_searchforward(); #endif } if (options & SEARCH_REV) { #ifdef WIN32 /* There is a bug in the Visual C++ 2.2 compiler which means that * dirc always ends up being '/' */ dirc = (dirc == '/') ? '?' : '/'; #else if (dirc == '/') dirc = '?'; else dirc = '/'; #endif } #ifdef FEAT_FOLDING /* 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 */ } else { if (hasFolding(pos.lnum, &pos.lnum, NULL)) pos.col = 0; } #endif #ifdef FEAT_SEARCH_EXTRA /* * Turn 'hlsearch' highlighting back on. */ if (no_hlsearch && !(options & SEARCH_KEEP)) { redraw_all_later(SOME_VALID); set_no_hlsearch(FALSE); } #endif /* * Repeat the search when pattern followed by ';', e.g. "/foo/;?bar". */ for (;;) { searchstr = pat; dircp = NULL; /* use previous pattern */ if (pat == NULL || *pat == NUL || *pat == dirc) { if (spats[RE_SEARCH].pat == NULL) /* no previous pattern */ { searchstr = spats[RE_SUBST].pat; if (searchstr == NULL) { emsg(_(e_noprevre)); retval = 0; goto end_do_search; } } else { /* make search_regcomp() use spats[RE_SEARCH].pat */ searchstr = (char_u *)""; } } if (pat != NULL && *pat != NUL) /* look for (new) offset */ { /* * Find end of regular expression. * If there is a matching '/' or '?', toss it. */ ps = strcopy; p = skip_regexp(pat, dirc, (int)p_magic, &strcopy); if (strcopy != ps) { /* 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 */ *p++ = NUL; } spats[0].off.line = FALSE; spats[0].off.end = FALSE; spats[0].off.off = 0; /* * Check for a line offset or a character offset. * For get_address (echo off) we don't check for a character * offset, because it is meaningless and the 's' could be a * substitute command. */ if (*p == '+' || *p == '-' || VIM_ISDIGIT(*p)) spats[0].off.line = TRUE; else if ((options & SEARCH_OPT) && (*p == 'e' || *p == 's' || *p == 'b')) { if (*p == 'e') /* end */ spats[0].off.end = SEARCH_END; ++p; } if (VIM_ISDIGIT(*p) || *p == '+' || *p == '-') /* got an offset */ { /* 'nr' or '+nr' or '-nr' */ if (VIM_ISDIGIT(*p) || VIM_ISDIGIT(*(p + 1))) spats[0].off.off = atol((char *)p); else if (*p == '-') /* single '-' */ spats[0].off.off = -1; else /* single '+' */ spats[0].off.off = 1; ++p; while (VIM_ISDIGIT(*p)) /* skip number */ ++p; } /* compute length of search command for get_address() */ searchcmdlen += (int)(p - pat); pat = p; /* put pat after search command */ } if ((options & SEARCH_ECHO) && messaging() && !cmd_silent && msg_silent == 0) { char_u *msgbuf; char_u *trunc; if (*searchstr == NUL) p = spats[0].pat; else p = searchstr; msgbuf = alloc((unsigned)(STRLEN(p) + 40)); if (msgbuf != NULL) { msgbuf[0] = dirc; if (enc_utf8 && utf_iscomposing(utf_ptr2char(p))) { /* Use a space to draw the composing char on. */ msgbuf[1] = ' '; STRCPY(msgbuf + 2, p); } else STRCPY(msgbuf + 1, p); if (spats[0].off.line || spats[0].off.end || spats[0].off.off) { p = msgbuf + STRLEN(msgbuf); *p++ = dirc; if (spats[0].off.end) *p++ = 'e'; else if (!spats[0].off.line) *p++ = 's'; if (spats[0].off.off > 0 || spats[0].off.line) *p++ = '+'; if (spats[0].off.off != 0 || spats[0].off.line) sprintf((char *)p, "%ld", spats[0].off.off); else *p = NUL; } msg_start(); trunc = msg_strtrunc(msgbuf, FALSE); #ifdef FEAT_RIGHTLEFT /* The search pattern could be shown on the right in rightleft * mode, but the 'ruler' and 'showcmd' area use it too, thus * 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; r = reverse_text(trunc != NULL ? trunc : msgbuf); if (r != NULL) { vim_free(trunc); trunc = r; } } #endif if (trunc != NULL) { msg_outtrans(trunc); vim_free(trunc); } else msg_outtrans(msgbuf); msg_clr_eos(); msg_check(); vim_free(msgbuf); gotocmdline(FALSE); out_flush(); msg_nowait = TRUE; /* don't wait for this message */ } } /* * 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) if (decl(&pos) == -1) break; if (c) /* at start of buffer */ { pos.lnum = 0; /* allow lnum == 0 here */ pos.col = MAXCOL; } } else { for (c = spats[0].off.off; c; ++c) if (incl(&pos) == -1) break; if (c) /* at end of buffer */ { pos.lnum = curbuf->b_ml.ml_line_count + 1; pos.col = 0; } } } #ifdef FEAT_FKMAP /* when in Farsi mode, reverse the character flow */ if (p_altkeymap && curwin->w_p_rl) lrFswap(searchstr,0); #endif c = searchit(curwin, curbuf, &pos, NULL, dirc == '/' ? FORWARD : BACKWARD, searchstr, count, spats[0].off.end + (options & (SEARCH_KEEP + SEARCH_PEEK + SEARCH_HIS + SEARCH_MSG + SEARCH_START + ((pat != NULL && *pat == ';') ? 0 : SEARCH_NOOF))), RE_LAST, (linenr_T)0, tm, timed_out); if (dircp != NULL) *dircp = dirc; /* restore second '/' or '?' for normal_cmd() */ if (c == FAIL) { retval = 0; goto end_do_search; } if (spats[0].off.end && oap != NULL) oap->inclusive = TRUE; /* 'e' includes last character */ retval = 1; /* pattern found */ /* * Add character and/or line offset */ if (!(options & SEARCH_NOOF) || (pat != NULL && *pat == ';')) { if (spats[0].off.line) /* Add the offset to the line number. */ { c = pos.lnum + spats[0].off.off; if (c < 1) pos.lnum = 1; else if (c > curbuf->b_ml.ml_line_count) pos.lnum = curbuf->b_ml.ml_line_count; else pos.lnum = c; pos.col = 0; retval = 2; /* pattern found, line offset added */ } else if (pos.col < MAXCOL - 2) /* just in case */ { /* to the right, check for end of file */ c = spats[0].off.off; if (c > 0) { while (c-- > 0) if (incl(&pos) == -1) break; } /* to the left, check for start of file */ else { while (c++ < 0) if (decl(&pos) == -1) break; } } } /* * The search command can be followed by a ';' to do another search. * For example: "/pat/;/foo/+3;?bar" * This is like doing another search command, except: * - The remembered direction '/' or '?' is from the first search. * - When an error happens the cursor isn't moved at all. * Don't do this when called by get_address() (it handles ';' itself). */ if (!(options & SEARCH_OPT) || pat == NULL || *pat != ';') break; dirc = *++pat; if (dirc != '?' && dirc != '/') { retval = 0; emsg(_("E386: Expected '?' or '/' after ';'")); goto end_do_search; } ++pat; } if (options & SEARCH_MARK) setpcmark(); curwin->w_cursor = pos; curwin->w_set_curswant = TRUE; end_do_search: if ((options & SEARCH_KEEP) || cmdmod.keeppatterns) spats[0].off = old_off; vim_free(strcopy); return retval; } #if defined(FEAT_INS_EXPAND) || defined(PROTO) /* * 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, int dir, char_u *pat) { linenr_T start = 0; char_u *ptr; char_u *p; if (buf->b_ml.ml_line_count == 0) return FAIL; for (;;) { pos->lnum += dir; if (pos->lnum < 1) { if (p_ws) { pos->lnum = buf->b_ml.ml_line_count; if (!shortmess(SHM_SEARCH)) give_warning((char_u *)_(top_bot_msg), TRUE); } else { pos->lnum = 1; break; } } else if (pos->lnum > buf->b_ml.ml_line_count) { if (p_ws) { pos->lnum = 1; if (!shortmess(SHM_SEARCH)) give_warning((char_u *)_(bot_top_msg), TRUE); } else { pos->lnum = 1; break; } } if (pos->lnum == start) break; if (start == 0) start = pos->lnum; ptr = ml_get_buf(buf, pos->lnum, FALSE); 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 */ 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 */ if ((p_ic ? MB_STRNICMP(p, pat, compl_length) : STRNCMP(p, pat, compl_length)) == 0) return OK; } } return FAIL; } #endif /* FEAT_INS_EXPAND */ /* * 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. * Do this "cap->count1" times. * Return FAIL or 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 col; char_u *p; int len; int stop = TRUE; if (c != NUL) /* normal search: remember args for repeat */ { if (!KeyStuffed) /* don't remember when redoing */ { *lastc = c; set_csearch_direction(dir); set_csearch_until(t_cmd); lastc_bytelen = (*mb_char2bytes)(c, lastc_bytes); if (cap->ncharC1 != 0) { lastc_bytelen += (*mb_char2bytes)(cap->ncharC1, lastc_bytes + lastc_bytelen); if (cap->ncharC2 != 0) lastc_bytelen += (*mb_char2bytes)(cap->ncharC2, lastc_bytes + lastc_bytelen); } } } else /* repeat previous search */ { if (*lastc == NUL && lastc_bytelen == 1) return FAIL; 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. */ /* 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 (dir == BACKWARD) cap->oap->inclusive = FALSE; else cap->oap->inclusive = TRUE; p = ml_get_curline(); col = curwin->w_cursor.col; len = (int)STRLEN(p); while (count--) { if (has_mbyte) { for (;;) { if (dir > 0) { col += (*mb_ptr2len)(p + col); if (col >= len) return FAIL; } else { if (col == 0) return FAIL; col -= (*mb_head_off)(p, p + col - 1) + 1; } if (lastc_bytelen == 1) { if (p[col] == c && stop) break; } else if (STRNCMP(p + col, lastc_bytes, lastc_bytelen) == 0 && stop) break; stop = TRUE; } } else { for (;;) { if ((col += dir) < 0 || col >= len) return FAIL; if (p[col] == c && stop) break; stop = TRUE; } } } if (t_cmd) { /* 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 */ col += lastc_bytelen - 1; else /* To previous char, which may be multi-byte. */ col -= (*mb_head_off)(p, p + col); } } curwin->w_cursor.col = col; return OK; } /* * "Other" Searches */ /* * 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); } /* * Return TRUE if the character before "linep[col]" equals "ch". * Return FALSE if "col" is zero. * Update "*prevcol" to the column of the previous character, unless "prevcol" * is NULL. * Handles multibyte string correctly. */ static int check_prevcol( char_u *linep, int col, int ch, int *prevcol) { --col; if (col > 0 && has_mbyte) col -= (*mb_head_off)(linep, linep + col); if (prevcol) *prevcol = col; return (col >= 0 && linep[col] == ch) ? TRUE : FALSE; } /* * Raw string start is found at linep[startpos.col - 1]. * Return TRUE if the matching end can be found between startpos and endpos. */ static int find_rawstring_end(char_u *linep, pos_T *startpos, pos_T *endpos) { char_u *p; char_u *delim_copy; size_t delim_len; linenr_T lnum; int found = FALSE; for (p = linep + startpos->col + 1; *p && *p != '('; ++p) ; delim_len = (p - linep) - startpos->col - 1; delim_copy = vim_strnsave(linep + startpos->col + 1, (int)delim_len); if (delim_copy == NULL) return FALSE; for (lnum = startpos->lnum; lnum <= endpos->lnum; ++lnum) { char_u *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 == ')' && p[delim_len + 1] == '"' && STRNCMP(delim_copy, p + 1, delim_len) == 0) { found = TRUE; break; } } if (found) break; } vim_free(delim_copy); return found; } /* * 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, int maxtravel) { 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 */ 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 */ #ifdef FEAT_LISP int lispcomm = FALSE; /* inside of Lisp-style comment */ int lisp = curbuf->b_p_lisp; /* engage Lisp-specific hacks ;) */ #endif pos = curwin->w_cursor; pos.coladd = 0; linep = ml_get(pos.lnum); 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 '#' */ if (flags & FM_BACKWARD) dir = BACKWARD; else if (flags & FM_FORWARD) dir = FORWARD; else 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 an star-slash, for * "[*" command, we just want to find any comment. */ if (initc == '/' || initc == '*' || initc == 'R') { comment_dir = dir; if (initc == '/') ignore_cend = TRUE; backwards = (dir == FORWARD) ? FALSE : TRUE; raw_string = (initc == 'R'); initc = NUL; } else if (initc != '#' && initc != NUL) { find_mps_values(&initc, &findc, &backwards, TRUE); if (findc == NUL) return NULL; } else { /* * 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 '%'. */ if (!cpo_match) { /* Are we before or at #if, #else etc.? */ ptr = skipwhite(linep); if (*ptr == '#' && pos.col <= (colnr_T)(ptr - linep)) { 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] == '/') { if (linep[pos.col + 1] == '*') { comment_dir = FORWARD; backwards = FALSE; pos.col++; } else if (pos.col > 0 && linep[pos.col - 1] == '*') { comment_dir = BACKWARD; backwards = TRUE; pos.col--; } } else if (linep[pos.col] == '*') { if (linep[pos.col + 1] == '/') { comment_dir = BACKWARD; backwards = TRUE; } else if (pos.col > 0 && linep[pos.col - 1] == '/') { comment_dir = FORWARD; backwards = FALSE; } } } /* * 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. */ if (linep[pos.col] == NUL && pos.col) --pos.col; for (;;) { initc = PTR2CHAR(linep + pos.col); if (initc == NUL) break; find_mps_values(&initc, &findc, &backwards, FALSE); if (findc) break; pos.col += MB_PTR2LEN(linep + pos.col); } if (!findc) { /* no brace in the line, maybe use " #if" then */ if (!cpo_match && *skipwhite(linep) == '#') hash_dir = 1; else return NULL; } else if (!cpo_bsl) { int col, bslcnt = 0; /* 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); } } } if (hash_dir) { /* * Look for matching #if, #else, #elif, or #endif */ if (oap != NULL) oap->motion_type = MLINE; /* Linewise for this case only */ if (initc != '#') { 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) hash_dir = -1; else return NULL; } pos.col = 0; while (!got_int) { if (hash_dir > 0) { if (pos.lnum == curbuf->b_ml.ml_line_count) break; } else if (pos.lnum == 1) break; pos.lnum += hash_dir; linep = ml_get(pos.lnum); line_breakcheck(); /* check for CTRL-C typed */ ptr = skipwhite(linep); if (*ptr != '#') continue; pos.col = (colnr_T) (ptr - linep); ptr = skipwhite(ptr + 1); if (hash_dir > 0) { if (STRNCMP(ptr, "if", 2) == 0) count++; else if (STRNCMP(ptr, "el", 2) == 0) { if (count == 0) return &pos; } else if (STRNCMP(ptr, "endif", 5) == 0) { if (count == 0) return &pos; count--; } } else { if (STRNCMP(ptr, "if", 2) == 0) { if (count == 0) return &pos; count--; } else if (initc == '#' && STRNCMP(ptr, "el", 2) == 0) { if (count == 0) return &pos; } else if (STRNCMP(ptr, "endif", 5) == 0) count++; } } return NULL; } } #ifdef FEAT_RIGHTLEFT /* 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 do_quotes = -1; start_in_quotes = MAYBE; CLEAR_POS(&match_pos); /* backward search: Check if this line contains a single-line comment */ if ((backwards && comment_dir) #ifdef FEAT_LISP || lisp #endif ) 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 */ #endif while (!got_int) { /* * Go to the next position, forward or backward. We could use * inc() and dec() here, but that is much slower */ if (backwards) { #ifdef FEAT_LISP /* 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.lnum == 1) /* start of file */ break; --pos.lnum; if (maxtravel > 0 && ++traveled > maxtravel) break; linep = ml_get(pos.lnum); 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 #ifdef FEAT_LISP || lisp #endif ) comment_col = check_linecomment(linep); #ifdef FEAT_LISP /* skip comment */ if (lisp && comment_col != MAXCOL) pos.col = comment_col; #endif } else { --pos.col; if (has_mbyte) pos.col -= (*mb_head_off)(linep, linep + pos.col); } } else /* forward search */ { if (linep[pos.col] == NUL /* at end of line, go to next one */ #ifdef FEAT_LISP /* 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 */ #ifdef FEAT_LISP /* line is exhausted and comment with it, * don't search for match in code */ || lispcomm #endif ) break; ++pos.lnum; if (maxtravel && traveled++ > maxtravel) break; linep = ml_get(pos.lnum); pos.col = 0; do_quotes = -1; line_breakcheck(); #ifdef FEAT_LISP if (lisp) /* find comment pos in new line */ comment_col = check_linecomment(linep); #endif } else { if (has_mbyte) pos.col += (*mb_ptr2len)(linep + pos.col); else ++pos.col; } } /* * If FM_BLOCKSTOP given, stop at a '{' or '}' in column 0. */ if (pos.col == 0 && (flags & FM_BLOCKSTOP) && (linep[0] == '{' || linep[0] == '}')) { if (linep[0] == findc && count == 0) /* match! */ return &pos; break; /* out of scope */ } if (comment_dir) { /* 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] == '/') { pos.col++; return &pos; } } else /* Searching backwards */ { /* * 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(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. */ if (!find_rawstring_end(linep, &pos, count > 0 ? &match_pos : &curwin->w_cursor)) { count++; match_pos = pos; match_pos.col--; } linep = ml_get(pos.lnum); /* may have been released */ } } else if ( linep[pos.col - 1] == '/' && linep[pos.col] == '*' && (pos.col == 1 || linep[pos.col - 2] != '*') && (int)pos.col < comment_col) { count++; match_pos = pos; match_pos.col--; } else if (linep[pos.col - 1] == '*' && linep[pos.col] == '/') { if (count > 0) pos = match_pos; else if (pos.col > 1 && linep[pos.col - 2] == '/' && (int)pos.col <= comment_col) pos.col -= 2; else if (ignore_cend) continue; else return NULL; return &pos; } } 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 (cpo_match) do_quotes = 0; else if (do_quotes == -1) { /* * 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) at_start = (do_quotes & 1); if (*ptr == '"' && (ptr == linep || ptr[-1] != '\'' || ptr[1] != '\'')) ++do_quotes; if (*ptr == '\\' && ptr[1] != NUL) ++ptr; } 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 (!do_quotes) { inquote = FALSE; if (ptr[-1] == '\\') { do_quotes = 1; if (start_in_quotes == MAYBE) { /* Do we need to use at_start here? */ inquote = TRUE; start_in_quotes = TRUE; } else if (backwards) inquote = TRUE; } if (pos.lnum > 1) { ptr = ml_get(pos.lnum - 1); if (*ptr && *(ptr + STRLEN(ptr) - 1) == '\\') { do_quotes = 1; if (start_in_quotes == MAYBE) { inquote = at_start; if (inquote) start_in_quotes = TRUE; } else if (!backwards) inquote = TRUE; } /* ml_get() only keeps one line, need to get linep again */ linep = ml_get(pos.lnum); } } } if (start_in_quotes == MAYBE) start_in_quotes = FALSE; /* * 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? */ c = PTR2CHAR(linep + pos.col); switch (c) { case NUL: /* at end of line without trailing backslash, reset inquote */ if (pos.col == 0 || linep[pos.col - 1] != '\\') { inquote = FALSE; start_in_quotes = FALSE; } break; case '"': /* a quote that is preceded with an odd number of backslashes is * ignored */ if (do_quotes) { int col; for (col = pos.col - 1; col >= 0; --col) if (linep[col] != '\\') break; if ((((int)pos.col - 1 - col) & 1) == 0) { inquote = !inquote; start_in_quotes = FALSE; } } 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 `'. */ case '\'': if (!cpo_match && initc != '\'' && findc != '\'') { if (backwards) { if (pos.col > 1) { if (linep[pos.col - 2] == '\'') { pos.col -= 2; break; } else if (linep[pos.col - 2] == '\\' && pos.col > 2 && linep[pos.col - 3] == '\'') { pos.col -= 3; break; } } } else if (linep[pos.col + 1]) /* forward search */ { if (linep[pos.col + 1] == '\\' && linep[pos.col + 2] && linep[pos.col + 3] == '\'') { pos.col += 3; break; } else if (linep[pos.col + 2] == '\'') { pos.col += 2; break; } } } /* FALLTHROUGH */ default: #ifdef FEAT_LISP /* * For Lisp skip over backslashed (), {} and []. * (actually, we skip #\( et al) */ if (curbuf->b_p_lisp && vim_strchr((char_u *)"(){}[]", c) != NULL && pos.col > 1 && check_prevcol(linep, pos.col, '\\', NULL) && check_prevcol(linep, pos.col - 1, '#', NULL)) break; #endif /* 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)) { int col, bslcnt = 0; if (!cpo_bsl) { 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. */ if (cpo_bsl || (bslcnt & 1) == match_escaped) { if (c == initc) count++; else { if (count == 0) return &pos; count--; } } } } } if (comment_dir == BACKWARD && count > 0) { pos = match_pos; return &pos; } return (pos_T *)NULL; /* never found it */ } /* * Check if line[] contains a / / comment. * Return MAXCOL if not, otherwise return the column. * TODO: skip strings. */ static int check_linecomment(char_u *line) { char_u *p; p = line; #ifdef FEAT_LISP /* skip Lispish one-line comments */ if (curbuf->b_p_lisp) { if (vim_strchr(p, ';') != NULL) /* there may be comments */ { int in_str = FALSE; /* inside of string */ p = line; /* scan from start */ while ((p = vim_strpbrk(p, (char_u *)"\";")) != NULL) { if (*p == '"') { if (in_str) { if (*(p - 1) != '\\') /* skip escaped quote */ in_str = FALSE; } else if (p == line || ((p - line) >= 2 /* skip #\" form */ && *(p - 1) != '\\' && *(p - 2) != '#')) in_str = TRUE; } else if (!in_str && ((p - line) < 2 || (*(p - 1) != '\\' && *(p - 2) != '#'))) break; /* found! */ ++p; } } else p = NULL; } else #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 */ if (p[1] == '/' && (p == line || p[-1] != '*' || p[2] != '*')) break; ++p; } if (p == NULL) return MAXCOL; return (int)(p - line); } /* * Move cursor briefly to character matching the one under the cursor. * Used for Insert mode and "r" command. * Show the match only if it is visible on the screen. * If there isn't a match, then beep. */ void showmatch( int c) /* char to show match for */ { pos_T *lpos, save_cursor; pos_T mpos; colnr_T vcol; long save_so; long save_siso; #ifdef CURSOR_SHAPE int save_state; #endif colnr_T save_dollar_vcol; char_u *p; /* * Only show match for chars in the 'matchpairs' option. */ /* 'matchpairs' is "x:y,x:y" */ for (p = curbuf->b_p_mps; *p != NUL; ++p) { #ifdef FEAT_RIGHTLEFT if (PTR2CHAR(p) == c && (curwin->w_p_rl ^ p_ri)) break; #endif p += MB_PTR2LEN(p) + 1; if (PTR2CHAR(p) == c #ifdef FEAT_RIGHTLEFT && !(curwin->w_p_rl ^ p_ri) #endif ) break; p += MB_PTR2LEN(p); if (*p == NUL) return; } 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) getvcol(curwin, lpos, NULL, &vcol, NULL); 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 */ save_cursor = curwin->w_cursor; save_so = p_so; save_siso = p_siso; /* 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 */ save_dollar_vcol = dollar_vcol; #ifdef CURSOR_SHAPE save_state = State; State = SHOWMATCH; ui_cursor_shape(); /* may show different cursor shape */ #endif curwin->w_cursor = mpos; /* move to matching char */ p_so = 0; /* don't use 'scrolloff' here */ p_siso = 0; /* don't use 'sidescrolloff' here */ showruler(FALSE); setcursor(); 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. */ dollar_vcol = save_dollar_vcol; /* * brief pause, unless 'm' is present in 'cpo' and a character is * available. */ if (vim_strchr(p_cpo, CPO_SHOWMATCH) != NULL) ui_delay(p_mat * 100L, TRUE); else if (!char_avail()) ui_delay(p_mat * 100L, FALSE); curwin->w_cursor = save_cursor; /* restore cursor position */ p_so = save_so; p_siso = save_siso; #ifdef CURSOR_SHAPE State = save_state; ui_cursor_shape(); /* may show different cursor shape */ #endif } } } /* * Find the start of the next sentence, searching in the direction specified * by the "dir" argument. The cursor is positioned on the start of the next * sentence when found. If the next sentence is found, return OK. Return FAIL * otherwise. See ":h sentence" for the precise definition of a "sentence" * text object. */ int findsent(int dir, long count) { pos_T pos, tpos; int c; int (*func)(pos_T *); int startlnum; int noskip = FALSE; /* do not skip blanks */ int cpo_J; int found_dot; pos = curwin->w_cursor; if (dir == FORWARD) func = incl; else func = decl; while (count--) { /* * if on an empty line, skip upto a non-empty line */ if (gchar_pos(&pos) == NUL) { do if ((*func)(&pos) == -1) break; while (gchar_pos(&pos) == NUL); if (dir == FORWARD) goto found; } /* * if on the start of a paragraph or a section and searching forward, * go to the next line */ else if (dir == FORWARD && pos.col == 0 && startPS(pos.lnum, NUL, FALSE)) { if (pos.lnum == curbuf->b_ml.ml_line_count) return FAIL; ++pos.lnum; goto found; } else if (dir == BACKWARD) decl(&pos); // go back to the previous non-white non-punctuation character found_dot = FALSE; while (c = gchar_pos(&pos), VIM_ISWHITE(c) || vim_strchr((char_u *)".!?)]\"'", c) != NULL) { tpos = pos; if (decl(&tpos) == -1 || (LINEEMPTY(tpos.lnum) && dir == FORWARD)) break; if (found_dot) break; if (vim_strchr((char_u *) ".!?", c) != NULL) found_dot = TRUE; if (vim_strchr((char_u *) ")]\"'", c) != NULL && vim_strchr((char_u *) ".!?)]\"'", gchar_pos(&tpos)) == NULL) break; decl(&pos); } /* remember the line where the search started */ startlnum = pos.lnum; cpo_J = vim_strchr(p_cpo, CPO_ENDOFSENT) != NULL; for (;;) /* find end of sentence */ { c = gchar_pos(&pos); if (c == NUL || (pos.col == 0 && startPS(pos.lnum, NUL, FALSE))) { if (dir == BACKWARD && pos.lnum != startlnum) ++pos.lnum; break; } if (c == '.' || c == '!' || c == '?') { tpos = pos; do if ((c = inc(&tpos)) == -1) break; while (vim_strchr((char_u *)")]\"'", c = gchar_pos(&tpos)) != NULL); if (c == -1 || (!cpo_J && (c == ' ' || c == '\t')) || c == NUL || (cpo_J && (c == ' ' && inc(&tpos) >= 0 && gchar_pos(&tpos) == ' '))) { pos = tpos; if (gchar_pos(&pos) == NUL) /* skip NUL at EOL */ inc(&pos); break; } } if ((*func)(&pos) == -1) { if (count) return FAIL; noskip = TRUE; break; } } found: /* skip white space */ while (!noskip && ((c = gchar_pos(&pos)) == ' ' || c == '\t')) if (incl(&pos) == -1) break; } setpcmark(); curwin->w_cursor = pos; return OK; } /* * Find the next paragraph or section in direction 'dir'. * Paragraphs are currently supposed to be separated by empty lines. * If 'what' is NUL we go to the next paragraph. * If 'what' is '{' or '}' we go to the next section. * If 'both' is TRUE also stop at '}'. * Return TRUE if the next paragraph or section was found. */ int findpar( 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 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 */ #endif curr = curwin->w_cursor.lnum; while (count--) { did_skip = FALSE; for (first = TRUE; ; first = FALSE) { if (*ml_get(curr) != NUL) did_skip = TRUE; #ifdef FEAT_FOLDING /* skip folded lines */ fold_skipped = FALSE; if (first && hasFolding(curr, &fold_first, &fold_last)) { curr = ((dir > 0) ? fold_last : fold_first) + dir; fold_skipped = TRUE; } #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. */ if (!first && did_skip && (startPS(curr, what, both) || (posix && what == NUL && *ml_get(curr) == '{'))) break; #ifdef FEAT_FOLDING if (fold_skipped) curr -= dir; #endif if ((curr += dir) < 1 || curr > curbuf->b_ml.ml_line_count) { if (count) return FALSE; curr -= dir; break; } } } setpcmark(); 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. */ if ((curwin->w_cursor.col = (colnr_T)STRLEN(line)) != 0) { --curwin->w_cursor.col; curwin->w_cursor.col -= (*mb_head_off)(line, line + curwin->w_cursor.col); *pincl = TRUE; } } else curwin->w_cursor.col = 0; return TRUE; } /* * check if the string 's' is a nroff macro that is in option 'opt' */ static int inmacro(char_u *opt, char_u *s) { char_u *macro; 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. */ if ( (macro[0] == s[0] || (macro[0] == ' ' && (s[0] == NUL || s[0] == ' '))) && (macro[1] == s[1] || ((macro[1] == NUL || macro[1] == ' ') && (s[0] == NUL || s[1] == NUL || s[1] == ' ')))) break; ++macro; if (macro[0] == NUL) break; } return (macro[0] != NUL); } /* * startPS: return TRUE if line 'lnum' is the start of a section or paragraph. * If 'para' is '{' or '}' only check for sections. * If 'both' is TRUE also stop at '}' */ int startPS(linenr_T lnum, int para, int both) { char_u *s; s = ml_get(lnum); if (*s == para || *s == '\f' || (both && *s == '}')) return TRUE; if (*s == '.' && (inmacro(p_sections, s + 1) || (!para && inmacro(p_para, s + 1)))) return TRUE; return FALSE; } /* * The following routines do the word searches performed by the 'w', 'W', * 'b', 'B', 'e', and 'E' commands. */ /* * To perform these searches, characters are placed into one of three * classes, and transitions between classes determine word boundaries. * * The classes are: * * 0 - white space * 1 - punctuation * 2 or higher - keyword characters (letters, digits and underscore) */ static int cls_bigword; /* TRUE for "W", "B" or "E" */ /* * cls() - returns the class of character at curwin->w_cursor * * If a 'W', 'B', or 'E' motion is being done (cls_bigword == TRUE), chars * from class 2 and higher are reported as class 1 since only white space * boundaries are of interest. */ static int cls(void) { int c; c = gchar_cursor(); #ifdef FEAT_FKMAP /* when 'akm' (Farsi mode), take care of Farsi blank */ if (p_altkeymap && c == F_BLANK) return 0; #endif if (c == ' ' || c == '\t' || c == NUL) return 0; if (enc_dbcs != 0 && c > 0xFF) { /* If cls_bigword, report multi-byte chars as class 1. */ if (enc_dbcs == DBCS_KOR && cls_bigword) return 1; /* process code leading/trailing bytes */ return dbcs_class(((unsigned)c >> 8), (c & 0xFF)); } if (enc_utf8) { c = utf_class(c); if (c != 0 && cls_bigword) return 1; return c; } /* If cls_bigword is TRUE, report all non-blanks as class 1. */ if (cls_bigword) return 1; if (vim_iswordc(c)) return 2; return 1; } /* * fwd_word(count, type, eol) - move forward one word * * Returns FAIL if the cursor was already at the end of the file. * If eol is TRUE, last word stops at end of line (for operators). */ int fwd_word( long count, int bigword, /* "W", "E" or "B" */ int eol) { int sclass; /* starting class */ int i; int last_line; 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. */ if (hasFolding(curwin->w_cursor.lnum, NULL, &curwin->w_cursor.lnum)) coladvance((colnr_T)MAXCOL); #endif sclass = cls(); /* * We always move at least one character, unless on the last * character in the buffer. */ 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 */ return FAIL; if (i >= 1 && eol && count == 0) /* started at last char in line */ return OK; /* * Go one char past end of current word (if any) */ if (sclass != 0) while (cls() == sclass) { i = inc_cursor(); if (i == -1 || (i >= 1 && eol && count == 0)) return OK; } /* * go to next non-white */ while (cls() == 0) { /* * We'll stop if we land on a blank line */ if (curwin->w_cursor.col == 0 && *ml_get_curline() == NUL) break; i = inc_cursor(); if (i == -1 || (i >= 1 && eol && count == 0)) return OK; } } return OK; } /* * bck_word() - move backward 'count' words * * If stop is TRUE and we are already on the start of a word, move one less. * * Returns FAIL if top of the file was reached. */ int bck_word(long count, int bigword, int stop) { 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. */ 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 */ return FAIL; if (!stop || sclass == cls() || sclass == 0) { /* * Skip white space before the word. * Stop on an empty line. */ while (cls() == 0) { if (curwin->w_cursor.col == 0 && LINEEMPTY(curwin->w_cursor.lnum)) goto finished; if (dec_cursor() == -1) /* hit start of file, stop here */ return OK; } /* * Move backward to start of this word. */ if (skip_chars(cls(), BACKWARD)) return OK; } inc_cursor(); /* overshot - forward one */ finished: stop = FALSE; } return OK; } /* * end_word() - move to the end of the word * * There is an apparent bug in the 'e' motion of the real vi. At least on the * System V Release 3 version for the 80386. Unlike 'b' and 'w', the 'e' * motion crosses blank lines. When the real vi crosses a blank line in an * 'e' motion, the cursor is placed on the FIRST character of the next * non-blank line. The 'E' command, however, works correctly. Since this * appears to be a bug, I have not duplicated it here. * * Returns FAIL if end of the file was reached. * * If stop is TRUE and we are already on the end of a word, move one less. * If empty is TRUE stop on an empty line. */ int end_word( long count, int bigword, int stop, int empty) { 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. */ if (hasFolding(curwin->w_cursor.lnum, NULL, &curwin->w_cursor.lnum)) coladvance((colnr_T)MAXCOL); #endif sclass = cls(); if (inc_cursor() == -1) return FAIL; /* * If we're in the middle of a word, we just have to move to the end * of it. */ if (cls() == sclass && sclass != 0) { /* * Move forward to end of the current word */ if (skip_chars(sclass, FORWARD)) return FAIL; } else if (!stop || sclass == 0) { /* * We were at the end of a word. Go to the end of the next word. * First skip white space, if 'empty' is TRUE, stop at empty line. */ while (cls() == 0) { if (empty && curwin->w_cursor.col == 0 && LINEEMPTY(curwin->w_cursor.lnum)) goto finished; if (inc_cursor() == -1) /* hit end of file, stop here */ return FAIL; } /* * Move forward to the end of this word. */ if (skip_chars(cls(), FORWARD)) return FAIL; } dec_cursor(); /* overshot - one char backward */ finished: stop = FALSE; /* we move only one word less */ } return OK; } /* * Move back to the end of the word. * * Returns FAIL if start of the file was reached. */ int bckend_word( long count, int bigword, /* TRUE for "B" */ int eol) /* TRUE: stop at end of line. */ { int sclass; /* starting class */ int i; curwin->w_cursor.coladd = 0; cls_bigword = bigword; while (--count >= 0) { sclass = cls(); if ((i = dec_cursor()) == -1) return FAIL; if (eol && i == 1) return OK; /* * Move backward to before the start of this word. */ if (sclass != 0) { while (cls() == sclass) if ((i = dec_cursor()) == -1 || (eol && i == 1)) return OK; } /* * Move backward to end of the previous word */ while (cls() == 0) { if (curwin->w_cursor.col == 0 && LINEEMPTY(curwin->w_cursor.lnum)) break; if ((i = dec_cursor()) == -1 || (eol && i == 1)) return OK; } } return OK; } /* * Skip a row of characters of the same class. * Return TRUE when end-of-file reached, FALSE otherwise. */ static int skip_chars(int cclass, int dir) { while (cls() == cclass) if ((dir == FORWARD ? inc_cursor() : dec_cursor()) == -1) return TRUE; return FALSE; } #ifdef FEAT_TEXTOBJ /* * Go back to the start of the word or the start of white space */ static void back_in_line(void) { int sclass; /* starting class */ sclass = cls(); for (;;) { if (curwin->w_cursor.col == 0) /* stop at start of line */ break; dec_cursor(); if (cls() != sclass) /* stop at start of word */ { inc_cursor(); break; } } } static void find_first_blank(pos_T *posp) { int c; while (decl(posp) != -1) { c = gchar_pos(posp); if (!VIM_ISWHITE(c)) { incl(posp); break; } } } /* * Skip count/2 sentences and count/2 separating white spaces. */ static void findsent_forward( long count, int at_start_sent) /* cursor is at start of sentence */ { while (count--) { findsent(FORWARD, 1L); if (at_start_sent) find_first_blank(&curwin->w_cursor); if (count == 0 || at_start_sent) decl(&curwin->w_cursor); at_start_sent = !at_start_sent; } } /* * Find word under cursor, cursor at end. * Used while an operator is pending, and in Visual mode. */ int current_word( oparg_T *oap, long count, int include, /* TRUE: include word and white space */ int bigword) /* FALSE == word, TRUE == WORD */ { pos_T start_pos; pos_T pos; int inclusive = TRUE; int include_white = FALSE; cls_bigword = bigword; CLEAR_POS(&start_pos); /* Correct cursor when 'selection' is exclusive */ if (VIsual_active && *p_sel == 'e' && LT_POS(VIsual, curwin->w_cursor)) dec_cursor(); /* * When Visual mode is not active, or when the VIsual area is only one * character, select the word and/or white space under the cursor. */ if (!VIsual_active || EQUAL_POS(curwin->w_cursor, VIsual)) { /* * Go to start of current word or white space. */ back_in_line(); start_pos = curwin->w_cursor; /* * If the start is on white space, and white space should be included * (" word"), or start is not on white space, and white space should * not be included ("word"), find end of word. */ if ((cls() == 0) == include) { if (end_word(1L, bigword, TRUE, TRUE) == FAIL) return FAIL; } else { /* * If the start is not on white space, and white space should be * included ("word "), or start is on white space and white * space should not be included (" "), find start of word. * If we end up in the first column of the next line (single char * word) back up to end of the line. */ fwd_word(1L, bigword, TRUE); if (curwin->w_cursor.col == 0) decl(&curwin->w_cursor); else oneleft(); if (include) include_white = TRUE; } if (VIsual_active) { /* should do something when inclusive == FALSE ! */ VIsual = start_pos; redraw_curbuf_later(INVERTED); /* update the inversion */ } else { oap->start = start_pos; oap->motion_type = MCHAR; } --count; } /* * When count is still > 0, extend with more objects. */ while (count > 0) { inclusive = TRUE; if (VIsual_active && LT_POS(curwin->w_cursor, VIsual)) { /* * In Visual mode, with cursor at start: move cursor back. */ if (decl(&curwin->w_cursor) == -1) return FAIL; if (include != (cls() != 0)) { if (bck_word(1L, bigword, TRUE) == FAIL) return FAIL; } else { if (bckend_word(1L, bigword, TRUE) == FAIL) return FAIL; (void)incl(&curwin->w_cursor); } } else { /* * Move cursor forward one word and/or white area. */ if (incl(&curwin->w_cursor) == -1) return FAIL; if (include != (cls() == 0)) { if (fwd_word(1L, bigword, TRUE) == FAIL && count > 1) return FAIL; /* * If end is just past a new-line, we don't want to include * the first character on the line. * Put cursor on last char of white. */ if (oneleft() == FAIL) inclusive = FALSE; } else { if (end_word(1L, bigword, TRUE, TRUE) == FAIL) return FAIL; } } --count; } if (include_white && (cls() != 0 || (curwin->w_cursor.col == 0 && !inclusive))) { /* * If we don't include white space at the end, move the start * to include some white space there. This makes "daw" work * better on the last word in a sentence (and "2daw" on last-but-one * word). Also when "2daw" deletes "word." at the end of the line * (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 */ curwin->w_cursor = start_pos; if (oneleft() == OK) { back_in_line(); if (cls() == 0 && curwin->w_cursor.col > 0) { if (VIsual_active) VIsual = curwin->w_cursor; else oap->start = curwin->w_cursor; } } curwin->w_cursor = pos; /* put cursor back at end */ } if (VIsual_active) { if (*p_sel == 'e' && inclusive && LTOREQ_POS(VIsual, curwin->w_cursor)) inc_cursor(); if (VIsual_mode == 'V') { VIsual_mode = 'v'; redraw_cmdline = TRUE; /* show mode later */ } } else oap->inclusive = inclusive; return OK; } /* * Find sentence(s) under the cursor, cursor at end. * When Visual active, extend it by one or more sentences. */ int current_sent(oparg_T *oap, long count, int include) { pos_T start_pos; pos_T pos; int start_blank; int c; int at_start_sent; long ncount; start_pos = curwin->w_cursor; pos = start_pos; findsent(FORWARD, 1L); /* Find start of next sentence. */ /* * When the Visual area is bigger than one character: Extend it. */ if (VIsual_active && !EQUAL_POS(start_pos, VIsual)) { extend: if (LT_POS(start_pos, VIsual)) { /* * Cursor at start of Visual area. * Find out where we are: * - in the white space before a sentence * - in a sentence or just after it * - at the start of a sentence */ at_start_sent = TRUE; decl(&pos); while (LT_POS(pos, curwin->w_cursor)) { c = gchar_pos(&pos); if (!VIM_ISWHITE(c)) { at_start_sent = FALSE; break; } incl(&pos); } if (!at_start_sent) { findsent(BACKWARD, 1L); if (EQUAL_POS(curwin->w_cursor, start_pos)) at_start_sent = TRUE; /* exactly at start of sentence */ else /* inside a sentence, go to its end (start of next) */ findsent(FORWARD, 1L); } if (include) /* "as" gets twice as much as "is" */ count *= 2; while (count--) { if (at_start_sent) find_first_blank(&curwin->w_cursor); c = gchar_cursor(); if (!at_start_sent || (!include && !VIM_ISWHITE(c))) findsent(BACKWARD, 1L); at_start_sent = !at_start_sent; } } else { /* * Cursor at end of Visual area. * Find out where we are: * - just before a sentence * - just before or in the white space before a sentence * - in a sentence */ incl(&pos); at_start_sent = TRUE; /* not just before a sentence */ if (!EQUAL_POS(pos, curwin->w_cursor)) { at_start_sent = FALSE; while (LT_POS(pos, curwin->w_cursor)) { c = gchar_pos(&pos); if (!VIM_ISWHITE(c)) { at_start_sent = TRUE; break; } incl(&pos); } if (at_start_sent) /* in the sentence */ findsent(BACKWARD, 1L); else /* in/before white before a sentence */ curwin->w_cursor = start_pos; } if (include) /* "as" gets twice as much as "is" */ count *= 2; findsent_forward(count, at_start_sent); if (*p_sel == 'e') ++curwin->w_cursor.col; } return OK; } /* * 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 */ incl(&pos); if (EQUAL_POS(pos, curwin->w_cursor)) { start_blank = TRUE; find_first_blank(&start_pos); /* go back to first blank */ } else { start_blank = FALSE; findsent(BACKWARD, 1L); start_pos = curwin->w_cursor; } if (include) ncount = count * 2; else { ncount = count; if (start_blank) --ncount; } if (ncount > 0) findsent_forward(ncount, TRUE); else decl(&curwin->w_cursor); if (include) { /* * If the blank in front of the sentence is included, exclude the * blanks at the end of the sentence, go back to the first blank. * If there are no trailing blanks, try to include leading blanks. */ if (start_blank) { find_first_blank(&curwin->w_cursor); c = gchar_pos(&curwin->w_cursor); /* VIM_ISWHITE() is a macro */ if (VIM_ISWHITE(c)) decl(&curwin->w_cursor); } else if (c = gchar_cursor(), !VIM_ISWHITE(c)) find_first_blank(&start_pos); } if (VIsual_active) { /* 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 */ } else { /* include a newline after the sentence, if there is one */ if (incl(&curwin->w_cursor) == -1) oap->inclusive = TRUE; else oap->inclusive = FALSE; oap->start = start_pos; oap->motion_type = MCHAR; } return OK; } /* * Find block under the cursor, cursor at end. * "what" and "other" are two matching parenthesis/brace/etc. */ int current_block( oparg_T *oap, long count, int include, /* TRUE == include white space */ int what, /* '(', '{', etc. */ int other) /* ')', '}', etc. */ { pos_T old_pos; pos_T *pos = NULL; pos_T start_pos; pos_T *end_pos; pos_T old_start, old_end; char_u *save_cpo; int sol = FALSE; /* '{' at start of line */ old_pos = curwin->w_cursor; old_end = curwin->w_cursor; /* remember where we started */ old_start = old_end; /* * If we start on '(', '{', ')', '}', etc., use the whole block inclusive. */ if (!VIsual_active || EQUAL_POS(VIsual, curwin->w_cursor)) { setpcmark(); if (what == '{') /* ignore indent */ while (inindent(1)) if (inc_cursor() != 0) break; if (gchar_cursor() == what) /* 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 */ } else old_end = VIsual; /* * Search backwards for unclosed '(', '{', etc.. * Put this position in start_pos. * Ignore quotes here. Keep the "M" flag in 'cpo', as that is what the * user wants. */ save_cpo = p_cpo; p_cpo = (char_u *)(vim_strchr(p_cpo, CPO_MATCHBSL) != NULL ? "%M" : "%"); while (count-- > 0) { if ((pos = findmatch(NULL, what)) == NULL) break; curwin->w_cursor = *pos; start_pos = *pos; /* the findmatch for end_pos will overwrite *pos */ } p_cpo = save_cpo; /* * Search for matching ')', '}', etc. * Put this position in curwin->w_cursor. */ if (pos == NULL || (end_pos = findmatch(NULL, other)) == NULL) { curwin->w_cursor = old_pos; return FAIL; } curwin->w_cursor = *end_pos; /* * Try to exclude the '(', '{', ')', '}', etc. when "include" is FALSE. * If the ending '}', ')' or ']' is only preceded by indent, skip that * indent. But only if the resulting area is not smaller than what we * started with. */ while (!include) { incl(&start_pos); sol = (curwin->w_cursor.col == 0); decl(&curwin->w_cursor); while (inindent(1)) { sol = TRUE; if (decl(&curwin->w_cursor) != 0) break; } /* * In Visual mode, when the resulting area is not bigger than what we * started with, extend it to the next block, and then exclude again. */ if (!LT_POS(start_pos, old_start) && !LT_POS(old_end, curwin->w_cursor) && VIsual_active) { curwin->w_cursor = old_start; decl(&curwin->w_cursor); if ((pos = findmatch(NULL, what)) == NULL) { curwin->w_cursor = old_pos; return FAIL; } start_pos = *pos; curwin->w_cursor = *pos; if ((end_pos = findmatch(NULL, other)) == NULL) { curwin->w_cursor = old_pos; return FAIL; } curwin->w_cursor = *end_pos; } else break; } if (VIsual_active) { if (*p_sel == 'e') inc(&curwin->w_cursor); if (sol && gchar_cursor() != NUL) inc(&curwin->w_cursor); /* include the line break */ VIsual = start_pos; VIsual_mode = 'v'; redraw_curbuf_later(INVERTED); /* update the inversion */ showmode(); } else { oap->start = start_pos; oap->motion_type = MCHAR; oap->inclusive = FALSE; if (sol) incl(&curwin->w_cursor); else if (LTOREQ_POS(start_pos, curwin->w_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. */ curwin->w_cursor = start_pos; } return OK; } /* * Return TRUE if the cursor is on a "<aaa>" tag. Ignore "<aaa/>". * When "end_tag" is TRUE return TRUE if the cursor is on "</aaa>". */ static int in_html_tag( int end_tag) { char_u *line = ml_get_curline(); char_u *p; int c; int lc = NUL; pos_T pos; if (enc_dbcs) { char_u *lp = NULL; /* 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 (lc != '<') return FALSE; p = lp; } } else { for (p = line + curwin->w_cursor.col; p > line; ) { if (*p == '<') /* find '<' under/before cursor */ break; MB_PTR_BACK(line, p); if (*p == '>') /* find '>' before cursor */ break; } if (*p != '<') return FALSE; } pos.lnum = curwin->w_cursor.lnum; pos.col = (colnr_T)(p - line); MB_PTR_ADV(p); if (end_tag) /* check that there is a '/' after the '<' */ return *p == '/'; /* check that there is no '/' after the '<' */ if (*p == '/') return FALSE; /* check that the matching '>' is not preceded by '/' */ for (;;) { if (inc(&pos) < 0) return FALSE; c = *ml_get_pos(&pos); if (c == '>') break; lc = c; } return lc != '/'; } /* * Find tag block under the cursor, cursor at end. */ int current_tagblock( oparg_T *oap, long count_arg, int include) /* TRUE == include white space */ { long count = count_arg; long n; pos_T old_pos; pos_T start_pos; pos_T end_pos; pos_T old_start, old_end; char_u *spat, *epat; char_u *p; char_u *cp; int len; int r; int do_include = include; int save_p_ws = p_ws; int retval = FAIL; int is_inclusive = TRUE; p_ws = FALSE; old_pos = curwin->w_cursor; 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 */ /* * If we start on "<aaa>" select that block. */ if (!VIsual_active || EQUAL_POS(VIsual, curwin->w_cursor)) { setpcmark(); /* ignore indent */ while (inindent(1)) if (inc_cursor() != 0) break; if (in_html_tag(FALSE)) { /* 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 */ while (*ml_get_cursor() != '<') if (dec_cursor() < 0) break; dec_cursor(); old_end = curwin->w_cursor; } } else if (LT_POS(VIsual, curwin->w_cursor)) { old_start = VIsual; curwin->w_cursor = VIsual; /* cursor at low end of Visual */ } else old_end = VIsual; again: /* * Search backwards for unclosed "<aaa>". * Put this position in start_pos. */ for (n = 0; n < count; ++n) { if (do_searchpair((char_u *)"<[^ \t>/!]\\+\\%(\\_s\\_[^>]\\{-}[^/]>\\|$\\|\\_s\\=>\\)", (char_u *)"", (char_u *)"</[^>]*>", BACKWARD, NULL, 0, NULL, (linenr_T)0, 0L) <= 0) { curwin->w_cursor = old_pos; goto theend; } } start_pos = curwin->w_cursor; /* * Search for matching "</aaa>". First isolate the "aaa". */ inc_cursor(); p = ml_get_cursor(); for (cp = p; *cp != NUL && *cp != '>' && !VIM_ISWHITE(*cp); MB_PTR_ADV(cp)) ; len = (int)(cp - p); if (len == 0) { curwin->w_cursor = old_pos; goto theend; } spat = alloc(len + 31); epat = alloc(len + 9); if (spat == NULL || epat == NULL) { vim_free(spat); vim_free(epat); curwin->w_cursor = old_pos; goto theend; } sprintf((char *)spat, "<%.*s\\>\\%%(\\s\\_[^>]\\{-}[^/]>\\|>\\)\\c", len, p); sprintf((char *)epat, "</%.*s>\\c", len, p); r = do_searchpair(spat, (char_u *)"", epat, FORWARD, NULL, 0, NULL, (linenr_T)0, 0L); vim_free(spat); vim_free(epat); 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. */ count = 1; curwin->w_cursor = start_pos; goto again; } if (do_include) { /* Include up to the '>'. */ while (*ml_get_cursor() != '>') if (inc_cursor() < 0) break; } else { 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 */ if (*c == '<' && !VIsual_active && curwin->w_cursor.col == 0) /* do not decrement cursor */ is_inclusive = FALSE; else if (*c == '<') dec_cursor(); } end_pos = curwin->w_cursor; if (!do_include) { /* Exclude the start tag. */ curwin->w_cursor = start_pos; while (inc_cursor() >= 0) if (*ml_get_cursor() == '>') { inc_cursor(); start_pos = curwin->w_cursor; break; } curwin->w_cursor = end_pos; // If we are in Visual mode and now have the same text as before set // "do_include" and try again. if (VIsual_active && EQUAL_POS(start_pos, old_start) && EQUAL_POS(end_pos, old_end)) { do_include = TRUE; curwin->w_cursor = old_start; count = count_arg; goto again; } } if (VIsual_active) { /* 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 */ showmode(); } else { oap->start = start_pos; 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. */ curwin->w_cursor = start_pos; oap->inclusive = FALSE; } else oap->inclusive = is_inclusive; } retval = OK; theend: p_ws = save_p_ws; return retval; } int current_par( oparg_T *oap, long count, int include, /* TRUE == include white space */ int type) /* 'p' for paragraph, 'S' for section */ { linenr_T start_lnum; linenr_T end_lnum; int white_in_front; int dir; int start_is_white; int prev_start_is_white; int retval = OK; int do_white = FALSE; int t; int i; if (type == 'S') /* not implemented yet */ return FAIL; start_lnum = curwin->w_cursor.lnum; /* * When visual area is more than one line: extend it. */ if (VIsual_active && start_lnum != VIsual.lnum) { extend: if (start_lnum < VIsual.lnum) dir = BACKWARD; else dir = FORWARD; for (i = count; --i >= 0; ) { if (start_lnum == (dir == BACKWARD ? 1 : curbuf->b_ml.ml_line_count)) { retval = FAIL; break; } prev_start_is_white = -1; for (t = 0; t < 2; ++t) { start_lnum += dir; start_is_white = linewhite(start_lnum); if (prev_start_is_white == start_is_white) { start_lnum -= dir; break; } for (;;) { if (start_lnum == (dir == BACKWARD ? 1 : curbuf->b_ml.ml_line_count)) break; if (start_is_white != linewhite(start_lnum + dir) || (!start_is_white && startPS(start_lnum + (dir > 0 ? 1 : 0), 0, 0))) break; start_lnum += dir; } if (!include) break; if (start_lnum == (dir == BACKWARD ? 1 : curbuf->b_ml.ml_line_count)) break; prev_start_is_white = start_is_white; } } curwin->w_cursor.lnum = start_lnum; curwin->w_cursor.col = 0; return retval; } /* * First move back to the start_lnum of the paragraph or white lines */ white_in_front = linewhite(start_lnum); while (start_lnum > 1) { 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 */ { if (linewhite(start_lnum - 1) || startPS(start_lnum, 0, 0)) break; } --start_lnum; } /* * Move past the end of any white lines. */ end_lnum = start_lnum; while (end_lnum <= curbuf->b_ml.ml_line_count && linewhite(end_lnum)) ++end_lnum; --end_lnum; i = count; if (!include && white_in_front) --i; while (i--) { if (end_lnum == curbuf->b_ml.ml_line_count) return FAIL; if (!include) do_white = linewhite(end_lnum + 1); if (include || !do_white) { ++end_lnum; /* * skip to end of paragraph */ while (end_lnum < curbuf->b_ml.ml_line_count && !linewhite(end_lnum + 1) && !startPS(end_lnum + 1, 0, 0)) ++end_lnum; } if (i == 0 && white_in_front && include) break; /* * skip to end of white lines after paragraph */ if (include || do_white) while (end_lnum < curbuf->b_ml.ml_line_count && linewhite(end_lnum + 1)) ++end_lnum; } /* * If there are no empty lines at the end, try to find some empty lines at * the start (unless that has been done already). */ if (!white_in_front && !linewhite(end_lnum) && include) while (start_lnum > 1 && linewhite(start_lnum - 1)) --start_lnum; if (VIsual_active) { /* 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.lnum = start_lnum; VIsual.col = 0; } VIsual_mode = 'V'; redraw_curbuf_later(INVERTED); /* update the inversion */ showmode(); } else { oap->start.lnum = start_lnum; oap->start.col = 0; oap->motion_type = MLINE; } curwin->w_cursor.lnum = end_lnum; curwin->w_cursor.col = 0; return OK; } /* * Search quote char from string line[col]. * Quote character escaped by one of the characters in "escape" is not counted * as a quote. * Returns column number of "quotechar" or -1 when not found. */ static int find_next_quote( char_u *line, int col, int quotechar, char_u *escape) /* escape characters, can be NULL */ { int c; for (;;) { c = line[col]; if (c == NUL) return -1; else if (escape != NULL && vim_strchr(escape, c)) ++col; else if (c == quotechar) break; if (has_mbyte) col += (*mb_ptr2len)(line + col); else ++col; } return col; } /* * Search backwards in "line" from column "col_start" to find "quotechar". * Quote character escaped by one of the characters in "escape" is not counted * as a quote. * Return the found column or zero. */ static int find_prev_quote( char_u *line, int col_start, int quotechar, char_u *escape) /* escape characters, can be NULL */ { int n; while (col_start > 0) { --col_start; col_start -= (*mb_head_off)(line, line + col_start); n = 0; if (escape != NULL) while (col_start - n > 0 && vim_strchr(escape, line[col_start - n - 1]) != NULL) ++n; if (n & 1) col_start -= n; /* uneven number of escape chars, skip it */ else if (line[col_start] == quotechar) break; } return col_start; } /* * Find quote under the cursor, cursor at end. * Returns TRUE if found, else FALSE. */ int current_quote( oparg_T *oap, long count, int include, /* TRUE == include quote char */ int quotechar) /* Quote character */ { char_u *line = ml_get_curline(); int col_end; int col_start = curwin->w_cursor.col; int inclusive = FALSE; int vis_empty = TRUE; /* Visual selection <= 1 char */ int vis_bef_curs = FALSE; /* Visual starts before cursor */ int inside_quotes = FALSE; /* Looks like "i'" done before */ int selected_quote = FALSE; /* Has quote inside selection */ int i; /* Correct cursor when 'selection' is "exclusive". */ if (VIsual_active) { /* this only works within one line */ if (VIsual.lnum != curwin->w_cursor.lnum) return FALSE; vis_bef_curs = LT_POS(VIsual, curwin->w_cursor); if (*p_sel == 'e') { if (!vis_bef_curs) { /* VIsual needs to be start of Visual selection. */ pos_T t = curwin->w_cursor; curwin->w_cursor = VIsual; VIsual = t; vis_bef_curs = TRUE; } dec_cursor(); } vis_empty = EQUAL_POS(VIsual, curwin->w_cursor); } if (!vis_empty) { /* Check if the existing selection exactly spans the text inside * quotes. */ if (vis_bef_curs) { inside_quotes = VIsual.col > 0 && line[VIsual.col - 1] == quotechar && line[curwin->w_cursor.col] != NUL && line[curwin->w_cursor.col + 1] == quotechar; i = VIsual.col; col_end = curwin->w_cursor.col; } else { inside_quotes = curwin->w_cursor.col > 0 && line[curwin->w_cursor.col - 1] == quotechar && line[VIsual.col] != NUL && line[VIsual.col + 1] == quotechar; i = curwin->w_cursor.col; col_end = VIsual.col; } /* Find out if we have a quote in the selection. */ while (i <= col_end) if (line[i++] == quotechar) { selected_quote = TRUE; break; } } if (!vis_empty && line[col_start] == quotechar) { /* 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. */ col_start = find_next_quote(line, col_start + 1, quotechar, NULL); if (col_start < 0) return FALSE; col_end = find_next_quote(line, col_start + 1, quotechar, curbuf->b_p_qe); if (col_end < 0) { /* We were on a starting quote perhaps? */ col_end = col_start; col_start = curwin->w_cursor.col; } } else { col_end = find_prev_quote(line, col_start, quotechar, NULL); if (line[col_end] != quotechar) return FALSE; col_start = find_prev_quote(line, col_end, quotechar, curbuf->b_p_qe); if (line[col_start] != quotechar) { /* We were on an ending quote perhaps? */ col_start = col_end; col_end = curwin->w_cursor.col; } } } else if (line[col_start] == quotechar || !vis_empty) { int first_col = col_start; if (!vis_empty) { if (vis_bef_curs) first_col = find_next_quote(line, col_start, quotechar, NULL); else 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. */ col_start = 0; for (;;) { /* Find open quote character. */ col_start = find_next_quote(line, col_start, quotechar, NULL); if (col_start < 0 || col_start > first_col) return FALSE; /* Find close quote character. */ col_end = find_next_quote(line, col_start + 1, quotechar, curbuf->b_p_qe); if (col_end < 0) return FALSE; /* 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. */ 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. */ col_start = find_next_quote(line, col_start, quotechar, NULL); if (col_start < 0) return FALSE; } /* Find close quote character. */ col_end = find_next_quote(line, col_start + 1, quotechar, curbuf->b_p_qe); if (col_end < 0) return FALSE; } /* When "include" is TRUE, include spaces after closing quote or before * the starting quote. */ if (include) { if (VIM_ISWHITE(line[col_end + 1])) while (VIM_ISWHITE(line[col_end + 1])) ++col_end; else while (col_start > 0 && VIM_ISWHITE(line[col_start - 1])) --col_start; } /* 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. */ if (vis_empty || (vis_bef_curs && !selected_quote && (inside_quotes || (line[VIsual.col] != quotechar && (VIsual.col == 0 || line[VIsual.col - 1] != quotechar))))) { VIsual = curwin->w_cursor; redraw_curbuf_later(INVERTED); } } else { oap->start = curwin->w_cursor; oap->motion_type = MCHAR; } /* Set end position. */ curwin->w_cursor.col = col_end; if ((include || count > 1 /* After vi" another i" must include the ". */ || (!vis_empty && inside_quotes) ) && inc_cursor() == 2) inclusive = TRUE; if (VIsual_active) { if (vis_empty || vis_bef_curs) { /* decrement cursor when 'selection' is not exclusive */ if (*p_sel != 'e') dec_cursor(); } 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. */ if (inside_quotes || (!selected_quote && line[VIsual.col] != quotechar && (line[VIsual.col] == NUL || line[VIsual.col + 1] != quotechar))) { dec_cursor(); VIsual = curwin->w_cursor; } curwin->w_cursor.col = col_start; } if (VIsual_mode == 'V') { VIsual_mode = 'v'; redraw_cmdline = TRUE; /* show mode later */ } } else { /* Set inclusive and other oap's flags. */ oap->inclusive = inclusive; } return OK; } #endif /* FEAT_TEXTOBJ */ static int is_one_char(char_u *pattern, int move, pos_T *cur, int direction); /* * Find next search match under cursor, cursor at end. * Used while an operator is pending, and in Visual mode. */ int current_search( long count, int forward) // TRUE for forward, FALSE for backward { pos_T start_pos; // start position of the pattern match pos_T end_pos; // end position of the pattern match pos_T orig_pos; // position of the cursor at beginning pos_T pos; // position after the pattern int i; int dir; int result; // result of various function calls char_u old_p_ws = p_ws; int flags = 0; pos_T save_VIsual = VIsual; int one_char; /* wrapping should not occur */ p_ws = FALSE; /* Correct cursor when 'selection' is exclusive */ if (VIsual_active && *p_sel == 'e' && LT_POS(VIsual, curwin->w_cursor)) dec_cursor(); if (VIsual_active) { orig_pos = curwin->w_cursor; pos = curwin->w_cursor; /* make sure, searching further will extend the match */ if (VIsual_active) { if (forward) incl(&pos); else decl(&pos); } } else orig_pos = pos = curwin->w_cursor; /* Is the pattern is zero-width?, this time, don't care about the direction */ one_char = is_one_char(spats[last_idx].pat, TRUE, &curwin->w_cursor, FORWARD); if (one_char == -1) { p_ws = old_p_ws; return FAIL; /* pattern not found */ } /* * The trick is to first search backwards and then search forward again, * so that a match at the current cursor position will be correctly * captured. */ for (i = 0; i < 2; i++) { if (forward) dir = i; else dir = !i; flags = 0; if (!dir && !one_char) flags = SEARCH_END; end_pos = pos; result = searchit(curwin, curbuf, &pos, &end_pos, (dir ? FORWARD : BACKWARD), spats[last_idx].pat, (long) (i ? count : 1), SEARCH_KEEP | flags, RE_SEARCH, 0, NULL, NULL); /* 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) VIsual = save_VIsual; p_ws = old_p_ws; return FAIL; } else if (i == 0 && !result) { if (forward) { /* 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 */ 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)); } } p_ws = old_p_ws; } start_pos = pos; p_ws = old_p_ws; if (!VIsual_active) VIsual = start_pos; // put cursor on last character of match curwin->w_cursor = end_pos; if (LT_POS(VIsual, end_pos)) dec_cursor(); VIsual_active = TRUE; VIsual_mode = 'v'; if (VIsual_active) { redraw_curbuf_later(INVERTED); /* update the inversion */ if (*p_sel == 'e') { /* 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)) inc(&VIsual); } } #ifdef FEAT_FOLDING if (fdo_flags & FDO_SEARCH && KeyTyped) foldOpenCursor(); #endif may_start_select('c'); #ifdef FEAT_MOUSE setmouse(); #endif #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 */ clip_star.vmode = NUL; #endif redraw_curbuf_later(INVERTED); showmode(); return OK; } /* * Check if the pattern is one character long or zero-width. * If move is TRUE, check from the beginning of the buffer, else from position * "cur". * "direction" is FORWARD or BACKWARD. * Returns TRUE, FALSE or -1 for failure. */ static int is_one_char(char_u *pattern, int move, pos_T *cur, int direction) { regmmatch_T regmatch; int nmatched = 0; int result = -1; pos_T pos; int save_called_emsg = called_emsg; int flag = 0; if (pattern == NULL) pattern = spats[last_idx].pat; if (search_regcomp(pattern, RE_SEARCH, RE_SEARCH, SEARCH_KEEP, ®match) == FAIL) return -1; /* init startcol correctly */ regmatch.startpos[0].col = -1; /* move to match */ if (move) { CLEAR_POS(&pos); } else { pos = *cur; /* accept a match at the cursor position */ flag = SEARCH_START; } if (searchit(curwin, curbuf, &pos, NULL, direction, pattern, 1, SEARCH_KEEP + flag, RE_SEARCH, 0, NULL, NULL) != FAIL) { /* Zero-width pattern should match somewhere, then we can check if * start and end are in the same position. */ called_emsg = FALSE; do { regmatch.startpos[0].col++; nmatched = vim_regexec_multi(®match, curwin, curbuf, pos.lnum, regmatch.startpos[0].col, NULL, NULL); if (!nmatched) break; } while (direction == FORWARD ? regmatch.startpos[0].col < pos.col : regmatch.startpos[0].col > pos.col); if (!called_emsg) { result = (nmatched != 0 && regmatch.startpos[0].lnum == regmatch.endpos[0].lnum && regmatch.startpos[0].col == regmatch.endpos[0].col); /* one char width */ if (!result && inc(&pos) >= 0 && pos.col == regmatch.endpos[0].col) result = TRUE; } } called_emsg |= save_called_emsg; vim_regfree(regmatch.regprog); return result; } #if defined(FEAT_LISP) || defined(FEAT_CINDENT) || defined(FEAT_TEXTOBJ) \ || defined(PROTO) /* * return TRUE if line 'lnum' is empty or has white chars only. */ int linewhite(linenr_T lnum) { char_u *p; p = skipwhite(ml_get(lnum)); return (*p == NUL); } #endif #if defined(FEAT_FIND_ID) || defined(PROTO) /* * Find identifiers or defines in included files. * If p_ic && (compl_cont_status & CONT_SOL) then ptr must be in lowercase. */ 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? */ 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 */ { SearchedFile *files; /* Stack of included files */ SearchedFile *bigger; /* When we need more space */ int max_path_depth = 50; long match_count = 1; char_u *pat; char_u *new_fname; char_u *curr_fname = curbuf->b_fname; char_u *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; int define_matched; regmatch_T regmatch; regmatch_T incl_regmatch; regmatch_T def_regmatch; int matched = FALSE; int did_show = FALSE; int found = FALSE; int i; char_u *already = NULL; char_u *startp = NULL; char_u *inc_opt = NULL; #if defined(FEAT_QUICKFIX) win_T *curwin_save = NULL; #endif regmatch.regprog = NULL; incl_regmatch.regprog = NULL; def_regmatch.regprog = NULL; file_line = alloc(LSIZE); if (file_line == NULL) return; if (type != CHECK_PATH && type != FIND_DEFINE #ifdef FEAT_INS_EXPAND /* 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) #endif ) { 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 */ regmatch.rm_ic = ignorecase(pat); regmatch.regprog = vim_regcomp(pat, p_magic ? RE_MAGIC : 0); vim_free(pat); if (regmatch.regprog == NULL) goto fpip_end; } 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); if (incl_regmatch.regprog == NULL) goto fpip_end; incl_regmatch.rm_ic = FALSE; /* don't ignore case in incl. pat. */ } 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); if (def_regmatch.regprog == NULL) goto fpip_end; def_regmatch.rm_ic = FALSE; /* don't ignore case in define pat. */ } files = (SearchedFile *)lalloc_clear((long_u) (max_path_depth * sizeof(SearchedFile)), TRUE); if (files == NULL) goto fpip_end; old_files = max_path_depth; depth = depth_displayed = -1; 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 */ lnum = end_lnum; line = ml_get(lnum); for (;;) { if (incl_regmatch.regprog != NULL && vim_regexec(&incl_regmatch, line, (colnr_T)0)) { char_u *p_fname = (curr_fname == curbuf->b_fname) ? 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'. */ 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'. */ 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 */ for (i = 0;; i++) { if (i == depth + 1) i = old_files; if (i == max_path_depth) break; if (fullpathcmp(new_fname, files[i].name, TRUE) & FPC_SAME) { 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_home_replace_hl(new_fname); msg_puts(_(" (includes previously listed match)")); prev_fname = NULL; } } VIM_CLEAR(new_fname); already_searched = TRUE; break; } } } if (type == CHECK_PATH && (action == ACTION_SHOW_ALL || (new_fname == NULL && !already_searched))) { if (did_show) msg_putchar('\n'); /* cursor below last one */ else { gotocmdline(TRUE); /* cursor at status line */ msg_puts_title(_("--- Included files ")); if (action != ACTION_SHOW_ALL) msg_puts_title(_("not found ")); msg_puts_title(_("in path ---\n")); } did_show = TRUE; while (depth_displayed < depth && !got_int) { ++depth_displayed; for (i = 0; i < depth_displayed; i++) msg_puts(" "); msg_home_replace(files[depth_displayed].name); msg_puts(" -->\n"); } 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. */ msg_outtrans_attr(new_fname, HL_ATTR(HLF_D)); } else { /* * Isolate the file name. * Include the surrounding "" or <> if present. */ if (inc_opt != NULL && strstr((char *)inc_opt, "\\zs") != NULL) { /* 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 */ for (p = incl_regmatch.endp[0]; *p && !vim_isfilec(*p); p++) ; for (i = 0; vim_isfilec(p[i]); i++) ; } if (i == 0) { /* 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. */ else if (p > line) { if (p[-1] == '"' || p[-1] == '<') { --p; ++i; } if (p[i] == '"' || p[i] == '>') ++i; } save_char = p[i]; p[i] = NUL; msg_outtrans_attr(p, HL_ATTR(HLF_D)); p[i] = save_char; } if (new_fname == NULL && action == ACTION_SHOW_ALL) { if (already_searched) msg_puts(_(" (Already listed)")); else msg_puts(_(" NOT FOUND")); } } out_flush(); /* output each line directly */ } if (new_fname != NULL) { /* Push the new file onto the file stack */ if (depth + 1 == old_files) { bigger = (SearchedFile *)lalloc((long_u)( max_path_depth * 2 * sizeof(SearchedFile)), TRUE); if (bigger != NULL) { for (i = 0; i <= depth; i++) bigger[i] = files[i]; for (i = depth + 1; i < old_files + max_path_depth; i++) { bigger[i].fp = NULL; bigger[i].name = NULL; bigger[i].lnum = 0; bigger[i].matched = FALSE; } for (i = old_files; i < max_path_depth; i++) bigger[i + max_path_depth] = files[i]; old_files += max_path_depth; max_path_depth *= 2; vim_free(files); files = bigger; } } if ((files[depth + 1].fp = mch_fopen((char *)new_fname, "r")) == NULL) vim_free(new_fname); else { if (++depth == old_files) { /* * lalloc() for 'bigger' must have failed above. We * will forget one of our already visited files now. */ vim_free(files[old_files].name); ++old_files; } files[depth].name = curr_fname = new_fname; files[depth].lnum = 0; files[depth].matched = FALSE; #ifdef FEAT_INS_EXPAND if (action == ACTION_EXPAND) { msg_hist_off = TRUE; /* reset in msg_trunc_attr() */ vim_snprintf((char*)IObuff, IOSIZE, _("Scanning included file: %s"), (char *)new_fname); msg_trunc_attr((char *)IObuff, TRUE, HL_ATTR(HLF_R)); } else #endif if (p_verbose >= 5) { verbose_enter(); smsg(_("Searching included file %s"), (char *)new_fname); verbose_leave(); } } } } else { /* * 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, 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)) 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. */ if (def_regmatch.regprog == NULL || define_matched) { if (define_matched #ifdef FEAT_INS_EXPAND || (compl_cont_status & CONT_SOL) #endif ) { /* compare the first "len" chars from "ptr" */ startp = skipwhite(p); if (p_ic) matched = !MB_STRNICMP(startp, ptr, len); else matched = !STRNCMP(startp, ptr, len); if (matched && define_matched && whole && vim_iswordc(startp[len])) matched = FALSE; } else if (regmatch.regprog != NULL && 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 * looking for a define). A line starting with "# define" * is not considered to be a comment line. */ if (!define_matched && skip_comments) { #ifdef FEAT_COMMENTS if ((*line != '#' || 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 = skipwhite(line); if (matched || (p[0] == '/' && p[1] == '*') || p[0] == '*') #endif for (p = line; *p && p < startp; ++p) { if (matched && p[0] == '/' && (p[1] == '*' || p[1] == '/')) { matched = FALSE; /* After "//" all text is comment */ if (p[1] == '/') break; ++p; } else if (!matched && p[0] == '*' && p[1] == '/') { /* Can find match after "* /". */ matched = TRUE; ++p; } } } } } } if (matched) { #ifdef FEAT_INS_EXPAND if (action == ACTION_EXPAND) { int reuse = 0; int add_r; char_u *aux; if (depth == -1 && lnum == curwin->w_cursor.lnum) break; found = TRUE; aux = p = startp; if (compl_cont_status & CONT_ADDING) { p += compl_length; if (vim_iswordp(p)) goto exit_matched; p = find_word_start(p); } p = find_word_end(p); i = (int)(p - aux); if ((compl_cont_status & CONT_ADDING) && i == compl_length) { /* 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. */ if (depth < 0) { if (lnum >= end_lnum) goto exit_matched; line = ml_get(++lnum); } else if (vim_fgets(line = file_line, 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 */ already = aux = p = skipwhite(line); p = find_word_start(p); p = find_word_end(p); if (p > aux) { if (*aux != ')' && IObuff[i-1] != TAB) { if (IObuff[i-1] != ' ') IObuff[i++] = ' '; /* IObuf =~ "\(\k\|\i\).* ", thus i >= 2*/ if (p_js && (IObuff[i-2] == '.' || (vim_strchr(p_cpo, CPO_JOINSP) == NULL && (IObuff[i-2] == '?' || IObuff[i-2] == '!')))) IObuff[i++] = ' '; } /* 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); i += (int)(p - aux); reuse |= CONT_S_IPOS; } IObuff[i] = NUL; aux = IObuff; if (i == compl_length) goto exit_matched; } add_r = ins_compl_add_infercase(aux, i, p_ic, curr_fname == curbuf->b_fname ? NULL : curr_fname, dir, reuse); if (add_r == OK) /* if dir was BACKWARD then honor it just once */ dir = FORWARD; else if (add_r == FAIL) break; } else #endif if (action == ACTION_SHOW_ALL) { found = TRUE; if (!did_show) 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_home_replace_hl(curr_fname); prev_fname = curr_fname; } did_show = TRUE; if (!got_int) show_pat_in_path(line, type, TRUE, action, (depth == -1) ? NULL : files[depth].fp, (depth == -1) ? &lnum : &files[depth].lnum, match_count++); /* Set matched flag for this file and all the ones that * include it */ for (i = 0; i <= depth; ++i) files[i].matched = TRUE; } else if (--count <= 0) { found = TRUE; if (depth == -1 && lnum == curwin->w_cursor.lnum #if defined(FEAT_QUICKFIX) && g_do_tagpreview == 0 #endif ) emsg(_("E387: Match is on current line")); else if (action == ACTION_SHOW) { show_pat_in_path(line, type, did_show, action, (depth == -1) ? NULL : files[depth].fp, (depth == -1) ? &lnum : &files[depth].lnum, 1L); did_show = TRUE; } else { #ifdef FEAT_GUI need_mouse_correct = TRUE; #endif #if defined(FEAT_QUICKFIX) /* ":psearch" uses the preview window */ if (g_do_tagpreview != 0) { curwin_save = curwin; prepare_tagpreview(TRUE); } #endif if (action == ACTION_SPLIT) { if (win_split(0, 0) == FAIL) break; RESET_BINDING(curwin); } if (depth == -1) { /* 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 */ } else #endif setpcmark(); curwin->w_cursor.lnum = lnum; check_cursor(); } else { 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 */ curwin->w_cursor.lnum = files[depth].lnum; } } if (action != ACTION_SHOW) { curwin->w_cursor.col = (colnr_T)(startp - line); curwin->w_set_curswant = TRUE; } #if defined(FEAT_QUICKFIX) if (g_do_tagpreview != 0 && curwin != curwin_save && win_valid(curwin_save)) { /* Return cursor to where we were */ validate_cursor(); redraw_later(VALID); win_enter(curwin_save, TRUE); } #endif break; } #ifdef FEAT_INS_EXPAND exit_matched: #endif matched = FALSE; /* 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 #ifdef FEAT_INS_EXPAND && action == ACTION_EXPAND && !(compl_cont_status & CONT_SOL) #endif && *startp != NUL && *(p = startp + MB_PTR2LEN(startp)) != NUL) goto search_line; } line_breakcheck(); #ifdef FEAT_INS_EXPAND if (action == ACTION_EXPAND) ins_compl_check_keys(30, FALSE); if (got_int || compl_interrupted) #else if (got_int) #endif 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. */ while (depth >= 0 && !already && vim_fgets(line = file_line, LSIZE, files[depth].fp)) { fclose(files[depth].fp); --old_files; files[old_files].name = files[depth].name; files[old_files].matched = files[depth].matched; --depth; curr_fname = (depth == -1) ? curbuf->b_fname : files[depth].name; if (depth < depth_displayed) depth_displayed = depth; } if (depth >= 0) /* we could read the line */ { files[depth].lnum++; /* Remove any CR and LF from the line. */ i = (int)STRLEN(line); if (i > 0 && line[i - 1] == '\n') line[--i] = NUL; if (i > 0 && line[i - 1] == '\r') line[--i] = NUL; } else if (!already) { if (++lnum > end_lnum) break; line = ml_get(lnum); } already = NULL; } /* End of big for (;;) loop. */ /* Close any files that are still open. */ for (i = 0; i <= depth; i++) { fclose(files[i].fp); vim_free(files[i].name); } for (i = old_files; i < max_path_depth; i++) vim_free(files[i].name); vim_free(files); if (type == CHECK_PATH) { if (!did_show) { if (action != ACTION_SHOW_ALL) msg(_("All included files were found")); else msg(_("No included files")); } } else if (!found #ifdef FEAT_INS_EXPAND && action != ACTION_EXPAND #endif ) { #ifdef FEAT_INS_EXPAND if (got_int || compl_interrupted) #else if (got_int) #endif emsg(_(e_interr)); else if (type == FIND_DEFINE) emsg(_("E388: Couldn't find definition")); else emsg(_("E389: Couldn't find pattern")); } if (action == ACTION_SHOW || action == ACTION_SHOW_ALL) msg_end(); fpip_end: vim_free(file_line); vim_regfree(regmatch.regprog); vim_regfree(incl_regmatch.regprog); vim_regfree(def_regmatch.regprog); } static void show_pat_in_path( char_u *line, int type, int did_show, int action, FILE *fp, linenr_T *lnum, long count) { char_u *p; if (did_show) 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 */ return; for (;;) { p = line + STRLEN(line) - 1; if (fp != NULL) { /* We used fgets(), so get rid of newline at end */ if (p >= line && *p == '\n') --p; if (p >= line && *p == '\r') --p; *(p + 1) = NUL; } if (action == ACTION_SHOW_ALL) { sprintf((char *)IObuff, "%3ld: ", count); /* show match nr */ msg_puts((char *)IObuff); 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 */ /* 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 */ break; ++*lnum; } else { if (++*lnum > curbuf->b_ml.ml_line_count) break; line = ml_get(*lnum); } msg_putchar('\n'); } } #endif #ifdef FEAT_VIMINFO int read_viminfo_search_pattern(vir_T *virp, int force) { char_u *lp; int idx = -1; int magic = FALSE; int no_scs = FALSE; int off_line = FALSE; int off_end = 0; long off = 0; int setlast = FALSE; #ifdef FEAT_SEARCH_EXTRA static int hlsearch_on = FALSE; #endif char_u *val; /* * Old line types: * "/pat", "&pat": search/subst. pat * "~/pat", "~&pat": last used search/subst. pat * New line types: * "~h", "~H": hlsearch highlighting off/on * "~<magic><smartcase><line><end><off><last><which>pat" * <magic>: 'm' off, 'M' on * <smartcase>: 's' off, 'S' on * <line>: 'L' line offset, 'l' char offset * <end>: 'E' from end, 'e' from start * <off>: decimal, offset * <last>: '~' last used pattern * <which>: '/' search pat, '&' subst. pat */ lp = virp->vir_line; if (lp[0] == '~' && (lp[1] == 'm' || lp[1] == 'M')) /* new line type */ { if (lp[1] == 'M') /* magic on */ magic = TRUE; if (lp[2] == 's') no_scs = TRUE; if (lp[3] == 'L') off_line = TRUE; if (lp[4] == 'E') off_end = SEARCH_END; lp += 5; off = getdigits(&lp); } if (lp[0] == '~') /* use this pattern for last-used pattern */ { setlast = TRUE; lp++; } if (lp[0] == '/') idx = RE_SEARCH; else if (lp[0] == '&') idx = RE_SUBST; #ifdef FEAT_SEARCH_EXTRA else if (lp[0] == 'h') /* ~h: 'hlsearch' highlighting off */ hlsearch_on = FALSE; else if (lp[0] == 'H') /* ~H: 'hlsearch' highlighting on */ hlsearch_on = TRUE; #endif if (idx >= 0) { if (force || spats[idx].pat == NULL) { val = viminfo_readstring(virp, (int)(lp - virp->vir_line + 1), TRUE); if (val != NULL) { set_last_search_pat(val, idx, magic, setlast); vim_free(val); spats[idx].no_scs = no_scs; spats[idx].off.line = off_line; spats[idx].off.end = off_end; spats[idx].off.off = off; #ifdef FEAT_SEARCH_EXTRA if (setlast) set_no_hlsearch(!hlsearch_on); #endif } } } return viminfo_readline(virp); } void write_viminfo_search_pattern(FILE *fp) { if (get_viminfo_parameter('/') != 0) { #ifdef FEAT_SEARCH_EXTRA fprintf(fp, "\n# hlsearch on (H) or off (h):\n~%c", (no_hlsearch || find_viminfo_parameter('h') != NULL) ? 'h' : 'H'); #endif wvsp_one(fp, RE_SEARCH, "", '/'); wvsp_one(fp, RE_SUBST, _("Substitute "), '&'); } } static void wvsp_one( FILE *fp, /* file to write to */ int idx, /* spats[] index */ char *s, /* search pat */ int sc) /* dir char */ { if (spats[idx].pat != NULL) { fprintf(fp, _("\n# Last %sSearch Pattern:\n~"), s); /* off.dir is not stored, it's reset to forward */ fprintf(fp, "%c%c%c%c%ld%s%c", spats[idx].magic ? 'M' : 'm', /* magic */ spats[idx].no_scs ? 's' : 'S', /* smartcase */ spats[idx].off.line ? 'L' : 'l', /* line offset */ spats[idx].off.end ? 'E' : 'e', /* offset from end */ spats[idx].off.off, /* offset */ last_idx == idx ? "~" : "", /* last used pat */ sc); viminfo_writestring(fp, spats[idx].pat); } } #endif /* FEAT_VIMINFO */