1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
10 * search.c: code for normal mode searching commands
15 static void save_re_pat
__ARGS((int idx
, char_u
*pat
, int magic
));
17 static void set_vv_searchforward
__ARGS((void));
18 static int first_submatch
__ARGS((regmmatch_T
*rp
));
20 static int check_prevcol
__ARGS((char_u
*linep
, int col
, int ch
, int *prevcol
));
21 static int inmacro
__ARGS((char_u
*, char_u
*));
22 static int check_linecomment
__ARGS((char_u
*line
));
23 static int cls
__ARGS((void));
24 static int skip_chars
__ARGS((int, int));
26 static void back_in_line
__ARGS((void));
27 static void find_first_blank
__ARGS((pos_T
*));
28 static void findsent_forward
__ARGS((long count
, int at_start_sent
));
31 static void show_pat_in_path
__ARGS((char_u
*, int,
32 int, int, FILE *, linenr_T
*, long));
35 static void wvsp_one
__ARGS((FILE *fp
, int idx
, char *s
, int sc
));
39 * This file contains various searching-related routines. These fall into
41 * 1. string searches (for /, ?, n, and N)
42 * 2. character searches within a single line (for f, F, t, T, etc)
43 * 3. "other" kinds of searches like the '%' command, and 'word' searches.
49 * The string search functions are divided into two levels:
50 * lowest: searchit(); uses an pos_T for starting position and found match.
51 * Highest: do_search(); uses curwin->w_cursor; calls searchit().
53 * The last search pattern is remembered for repeating the same search.
54 * This pattern is shared between the :g, :s, ? and / commands.
55 * This is in search_regcomp().
57 * The actual string matching is done using a heavily modified version of
58 * Henry Spencer's regular expression library. See regexp.c.
61 /* The offset for a search command is store in a soff struct */
62 /* Note: only spats[0].off is really used */
65 int dir
; /* search direction, '/' or '?' */
66 int line
; /* search has line offset */
67 int end
; /* search set cursor at end */
68 long off
; /* line or char offset */
71 /* A search pattern and its attributes are stored in a spat struct */
74 char_u
*pat
; /* the pattern (in allocated memory) or NULL */
75 int magic
; /* magicness of the pattern */
76 int no_scs
; /* no smarcase for this pattern */
81 * Two search patterns are remembered: One for the :substitute command and
82 * one for other searches. last_idx points to the one that was used the last
85 static struct spat spats
[2] =
87 {NULL
, TRUE
, FALSE
, {'/', 0, 0, 0L}}, /* last used search pat */
88 {NULL
, TRUE
, FALSE
, {'/', 0, 0, 0L}} /* last used substitute pat */
91 static int last_idx
= 0; /* index in spats[] for RE_LAST */
93 #if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)
94 /* copy of spats[], for keeping the search patterns while executing autocmds */
95 static struct spat saved_spats
[2];
96 static int saved_last_idx
= 0;
97 # ifdef FEAT_SEARCH_EXTRA
98 static int saved_no_hlsearch
= 0;
102 static char_u
*mr_pattern
= NULL
; /* pattern used by search_regcomp() */
103 #ifdef FEAT_RIGHTLEFT
104 static int mr_pattern_alloced
= FALSE
; /* mr_pattern was allocated */
109 * Type used by find_pattern_in_path() to remember which included files have
110 * been searched already.
112 typedef struct SearchedFile
114 FILE *fp
; /* File pointer */
115 char_u
*name
; /* Full name of file */
116 linenr_T lnum
; /* Line we were up to in file */
117 int matched
; /* Found a match in this file */
122 * translate search pattern for vim_regcomp()
124 * pat_save == RE_SEARCH: save pat in spats[RE_SEARCH].pat (normal search cmd)
125 * pat_save == RE_SUBST: save pat in spats[RE_SUBST].pat (:substitute command)
126 * pat_save == RE_BOTH: save pat in both patterns (:global command)
127 * pat_use == RE_SEARCH: use previous search pattern if "pat" is NULL
128 * pat_use == RE_SUBST: use previous substitute pattern if "pat" is NULL
129 * pat_use == RE_LAST: use last used pattern if "pat" is NULL
130 * options & SEARCH_HIS: put search string in history
131 * options & SEARCH_KEEP: keep previous search pattern
133 * returns FAIL if failed, OK otherwise.
136 search_regcomp(pat
, pat_save
, pat_use
, options
, regmatch
)
141 regmmatch_T
*regmatch
; /* return: pattern and ignore-case flag */
150 * If no pattern given, use a previously defined pattern.
152 if (pat
== NULL
|| *pat
== NUL
)
154 if (pat_use
== RE_LAST
)
158 if (spats
[i
].pat
== NULL
) /* pattern was never defined */
160 if (pat_use
== RE_SUBST
)
168 magic
= spats
[i
].magic
;
169 no_smartcase
= spats
[i
].no_scs
;
172 else if (options
& SEARCH_HIS
) /* put new pattern in history */
173 add_to_history(HIST_SEARCH
, pat
, TRUE
, NUL
);
176 #ifdef FEAT_RIGHTLEFT
177 if (mr_pattern_alloced
)
179 vim_free(mr_pattern
);
180 mr_pattern_alloced
= FALSE
;
183 if (curwin
->w_p_rl
&& *curwin
->w_p_rlc
== 's')
187 rev_pattern
= reverse_text(pat
);
188 if (rev_pattern
== NULL
)
189 mr_pattern
= pat
; /* out of memory, keep normal pattern. */
192 mr_pattern
= rev_pattern
;
193 mr_pattern_alloced
= TRUE
;
201 * Save the currently used pattern in the appropriate place,
202 * unless the pattern should not be remembered.
204 if (!(options
& SEARCH_KEEP
))
206 /* search or global command */
207 if (pat_save
== RE_SEARCH
|| pat_save
== RE_BOTH
)
208 save_re_pat(RE_SEARCH
, pat
, magic
);
209 /* substitute or global command */
210 if (pat_save
== RE_SUBST
|| pat_save
== RE_BOTH
)
211 save_re_pat(RE_SUBST
, pat
, magic
);
214 regmatch
->rmm_ic
= ignorecase(pat
);
215 regmatch
->rmm_maxcol
= 0;
216 regmatch
->regprog
= vim_regcomp(pat
, magic
? RE_MAGIC
: 0);
217 if (regmatch
->regprog
== NULL
)
223 * Get search pattern used by search_regcomp().
231 #if defined(FEAT_RIGHTLEFT) || defined(PROTO)
233 * Reverse text into allocated memory.
234 * Returns the allocated string, NULL when out of memory.
245 * Reverse the pattern.
247 len
= (unsigned)STRLEN(s
);
248 rev
= alloc(len
+ 1);
252 for (s_i
= 0; s_i
< len
; ++s_i
)
259 mb_len
= (*mb_ptr2len
)(s
+ s_i
);
261 mch_memmove(rev
+ rev_i
, s
+ s_i
, mb_len
);
266 rev
[--rev_i
] = s
[s_i
];
276 save_re_pat(idx
, pat
, magic
)
281 if (spats
[idx
].pat
!= pat
)
284 if (RE_SEARCH
== idx
)
285 gui_macvim_add_to_find_pboard(pat
);
287 vim_free(spats
[idx
].pat
);
288 spats
[idx
].pat
= vim_strsave(pat
);
289 spats
[idx
].magic
= magic
;
290 spats
[idx
].no_scs
= no_smartcase
;
292 #ifdef FEAT_SEARCH_EXTRA
293 /* If 'hlsearch' set and search pat changed: need redraw. */
295 redraw_all_later(SOME_VALID
);
301 #if defined(FEAT_AUTOCMD) || defined(FEAT_EVAL) || defined(PROTO)
303 * Save the search patterns, so they can be restored later.
304 * Used before/after executing autocommands and user functions.
306 static int save_level
= 0;
309 save_search_patterns()
311 if (save_level
++ == 0)
313 saved_spats
[0] = spats
[0];
314 if (spats
[0].pat
!= NULL
)
315 saved_spats
[0].pat
= vim_strsave(spats
[0].pat
);
316 saved_spats
[1] = spats
[1];
317 if (spats
[1].pat
!= NULL
)
318 saved_spats
[1].pat
= vim_strsave(spats
[1].pat
);
319 saved_last_idx
= last_idx
;
320 # ifdef FEAT_SEARCH_EXTRA
321 saved_no_hlsearch
= no_hlsearch
;
327 restore_search_patterns()
329 if (--save_level
== 0)
331 vim_free(spats
[0].pat
);
332 spats
[0] = saved_spats
[0];
333 #if defined(FEAT_EVAL)
334 set_vv_searchforward();
336 vim_free(spats
[1].pat
);
337 spats
[1] = saved_spats
[1];
338 last_idx
= saved_last_idx
;
339 # ifdef FEAT_SEARCH_EXTRA
340 no_hlsearch
= saved_no_hlsearch
;
346 #if defined(EXITFREE) || defined(PROTO)
348 free_search_patterns()
350 vim_free(spats
[0].pat
);
351 vim_free(spats
[1].pat
);
353 # ifdef FEAT_RIGHTLEFT
354 if (mr_pattern_alloced
)
356 vim_free(mr_pattern
);
357 mr_pattern_alloced
= FALSE
;
365 * Return TRUE when case should be ignored for search pattern "pat".
366 * Uses the 'ignorecase' and 'smartcase' options.
376 if (ic
&& !no_smartcase
&& p_scs
377 #ifdef FEAT_INS_EXPAND
378 && !(ctrl_x_mode
&& curbuf
->b_p_inf
)
382 /* don't ignore case if pattern has uppercase */
388 if (has_mbyte
&& (l
= (*mb_ptr2len
)(p
)) > 1)
390 if (enc_utf8
&& utf_isupper(utf_ptr2char(p
)))
401 if (p
[1] == '_' && p
[2] != NUL
) /* skip "\_X" */
403 else if (p
[1] == '%' && p
[2] != NUL
) /* skip "\%X" */
405 else if (p
[1] != NUL
) /* skip "\X" */
410 else if (MB_ISUPPER(*p
))
419 no_smartcase
= FALSE
;
427 return spats
[last_idx
].pat
;
431 * Reset search direction to forward. For "gd" and "gD" commands.
436 spats
[0].off
.dir
= '/';
437 #if defined(FEAT_EVAL)
438 set_vv_searchforward();
442 #if defined(FEAT_EVAL) || defined(FEAT_VIMINFO)
444 * Set the last search pattern. For ":let @/ =" and viminfo.
445 * Also set the saved search pattern, so that this works in an autocommand.
448 set_last_search_pat(s
, idx
, magic
, setlast
)
455 if (RE_SEARCH
== idx
)
456 gui_macvim_add_to_find_pboard(s
);
459 vim_free(spats
[idx
].pat
);
460 /* An empty string means that nothing should be matched. */
462 spats
[idx
].pat
= NULL
;
464 spats
[idx
].pat
= vim_strsave(s
);
465 spats
[idx
].magic
= magic
;
466 spats
[idx
].no_scs
= FALSE
;
467 spats
[idx
].off
.dir
= '/';
468 #if defined(FEAT_EVAL)
469 set_vv_searchforward();
471 spats
[idx
].off
.line
= FALSE
;
472 spats
[idx
].off
.end
= FALSE
;
473 spats
[idx
].off
.off
= 0;
478 vim_free(saved_spats
[idx
].pat
);
479 saved_spats
[idx
] = spats
[0];
480 if (spats
[idx
].pat
== NULL
)
481 saved_spats
[idx
].pat
= NULL
;
483 saved_spats
[idx
].pat
= vim_strsave(spats
[idx
].pat
);
484 saved_last_idx
= last_idx
;
486 # ifdef FEAT_SEARCH_EXTRA
487 /* If 'hlsearch' set and search pat changed: need redraw. */
488 if (p_hls
&& idx
== last_idx
&& !no_hlsearch
)
489 redraw_all_later(SOME_VALID
);
494 #ifdef FEAT_SEARCH_EXTRA
496 * Get a regexp program for the last used search pattern.
497 * This is used for highlighting all matches in a window.
498 * Values returned in regmatch->regprog and regmatch->rmm_ic.
501 last_pat_prog(regmatch
)
502 regmmatch_T
*regmatch
;
504 if (spats
[last_idx
].pat
== NULL
)
506 regmatch
->regprog
= NULL
;
509 ++emsg_off
; /* So it doesn't beep if bad expr */
510 (void)search_regcomp((char_u
*)"", 0, last_idx
, SEARCH_KEEP
, regmatch
);
516 * lowest level search function.
517 * Search for 'count'th occurrence of pattern 'pat' in direction 'dir'.
518 * Start at position 'pos' and return the found position in 'pos'.
520 * if (options & SEARCH_MSG) == 0 don't give any messages
521 * if (options & SEARCH_MSG) == SEARCH_NFMSG don't give 'notfound' messages
522 * if (options & SEARCH_MSG) == SEARCH_MSG give all messages
523 * if (options & SEARCH_HIS) put search pattern in history
524 * if (options & SEARCH_END) return position at end of match
525 * if (options & SEARCH_START) accept match at pos itself
526 * if (options & SEARCH_KEEP) keep previous search pattern
527 * if (options & SEARCH_FOLD) match only once in a closed fold
528 * if (options & SEARCH_PEEK) check for typed char, cancel search
530 * Return FAIL (zero) for failure, non-zero for success.
531 * When FEAT_EVAL is defined, returns the index of the first matching
532 * subpattern plus one; one if there was none.
535 searchit(win
, buf
, pos
, dir
, pat
, count
, options
, pat_use
, stop_lnum
, tm
)
536 win_T
*win
; /* window to search in; can be NULL for a
537 buffer without a window! */
544 int pat_use
; /* which pattern to use when "pat" is empty */
545 linenr_T stop_lnum
; /* stop after this line number when != 0 */
546 proftime_T
*tm UNUSED
; /* timeout limit or NULL */
549 linenr_T lnum
; /* no init to shut up Apollo cc */
550 regmmatch_T regmatch
;
562 int save_called_emsg
= called_emsg
;
563 #ifdef FEAT_SEARCH_EXTRA
564 int break_loop
= FALSE
;
567 if (search_regcomp(pat
, RE_SEARCH
, pat_use
,
568 (options
& (SEARCH_HIS
+ SEARCH_KEEP
)), ®match
) == FAIL
)
570 if ((options
& SEARCH_MSG
) && !rc_did_emsg
)
571 EMSG2(_("E383: Invalid search string: %s"), mr_pattern
);
575 /* When not accepting a match at the start position set "extra_col" to a
576 * non-zero value. Don't do that when starting at MAXCOL, since MAXCOL +
578 if ((options
& SEARCH_START
) || pos
->col
== MAXCOL
)
581 /* Watch out for the "col" being MAXCOL - 2, used in a closed fold. */
582 else if (has_mbyte
&& pos
->lnum
>= 1 && pos
->lnum
<= buf
->b_ml
.ml_line_count
583 && pos
->col
< MAXCOL
- 2)
585 ptr
= ml_get_buf(buf
, pos
->lnum
, FALSE
) + pos
->col
;
589 extra_col
= (*mb_ptr2len
)(ptr
);
599 do /* loop for count */
601 start_pos
= *pos
; /* remember start pos for detecting no match */
602 found
= 0; /* default: not found */
603 at_first_line
= TRUE
; /* default: start in first line */
604 if (pos
->lnum
== 0) /* correct lnum for when starting in line 0 */
608 at_first_line
= FALSE
; /* not in first line now */
612 * Start searching in current line, unless searching backwards and
614 * If we are searching backwards, in column 0, and not including the
615 * current position, gain some efficiency by skipping back a line.
616 * Otherwise begin the search in the current line.
618 if (dir
== BACKWARD
&& start_pos
.col
== 0
619 && (options
& SEARCH_START
) == 0)
621 lnum
= pos
->lnum
- 1;
622 at_first_line
= FALSE
;
627 for (loop
= 0; loop
<= 1; ++loop
) /* loop twice if 'wrapscan' set */
629 for ( ; lnum
> 0 && lnum
<= buf
->b_ml
.ml_line_count
;
630 lnum
+= dir
, at_first_line
= FALSE
)
632 /* Stop after checking "stop_lnum", if it's set. */
633 if (stop_lnum
!= 0 && (dir
== FORWARD
634 ? lnum
> stop_lnum
: lnum
< stop_lnum
))
637 /* Stop after passing the "tm" time limit. */
638 if (tm
!= NULL
&& profile_passed_limit(tm
))
643 * Look for a match somewhere in line "lnum".
645 nmatched
= vim_regexec_multi(®match
, win
, buf
,
653 /* Abort searching on an error (e.g., out of stack). */
658 /* match may actually be in another line when using \zs */
659 matchpos
= regmatch
.startpos
[0];
660 endpos
= regmatch
.endpos
[0];
662 submatch
= first_submatch(®match
);
664 /* "lnum" may be past end of buffer for "\n\zs". */
665 if (lnum
+ matchpos
.lnum
> buf
->b_ml
.ml_line_count
)
668 ptr
= ml_get_buf(buf
, lnum
+ matchpos
.lnum
, FALSE
);
671 * Forward search in the first line: match should be after
672 * the start position. If not, continue at the end of the
673 * match (this is vi compatible) or on the next char.
675 if (dir
== FORWARD
&& at_first_line
)
679 * When the match starts in a next line it's certainly
680 * past the start position.
681 * When match lands on a NUL the cursor will be put
682 * one back afterwards, compare with that position,
683 * otherwise "/$" will get stuck on end of line.
685 while (matchpos
.lnum
== 0
686 && ((options
& SEARCH_END
)
688 && (int)endpos
.col
- 1
689 < (int)start_pos
.col
+ extra_col
)
691 - (ptr
[matchpos
.col
] == NUL
)
692 < (int)start_pos
.col
+ extra_col
)))
695 * If vi-compatible searching, continue at the end
696 * of the match, otherwise continue one position
699 if (vim_strchr(p_cpo
, CPO_SEARCH
) != NULL
)
703 /* end is in next line, thus no match in
708 matchcol
= endpos
.col
;
709 /* for empty match: advance one char */
710 if (matchcol
== matchpos
.col
711 && ptr
[matchcol
] != NUL
)
716 (*mb_ptr2len
)(ptr
+ matchcol
);
724 matchcol
= matchpos
.col
;
725 if (ptr
[matchcol
] != NUL
)
729 matchcol
+= (*mb_ptr2len
)(ptr
736 if (ptr
[matchcol
] == NUL
737 || (nmatched
= vim_regexec_multi(®match
,
738 win
, buf
, lnum
+ matchpos
.lnum
,
750 matchpos
= regmatch
.startpos
[0];
751 endpos
= regmatch
.endpos
[0];
753 submatch
= first_submatch(®match
);
756 /* Need to get the line pointer again, a
757 * multi-line search may have made it invalid. */
758 ptr
= ml_get_buf(buf
, lnum
+ matchpos
.lnum
, FALSE
);
766 * Now, if there are multiple matches on this line,
767 * we have to get the last one. Or the last one before
768 * the cursor, if we're on that line.
769 * When putting the new cursor at the end, compare
770 * relative to the end of the match.
775 /* Remember a position that is before the start
776 * position, we use it if it's the last match in
777 * the line. Always accept a position after
778 * wrapping around. */
780 || ((options
& SEARCH_END
)
781 ? (lnum
+ regmatch
.endpos
[0].lnum
783 || (lnum
+ regmatch
.endpos
[0].lnum
785 && (int)regmatch
.endpos
[0].col
- 1
787 <= (int)start_pos
.col
))
788 : (lnum
+ regmatch
.startpos
[0].lnum
790 || (lnum
+ regmatch
.startpos
[0].lnum
792 && (int)regmatch
.startpos
[0].col
794 <= (int)start_pos
.col
))))
797 matchpos
= regmatch
.startpos
[0];
798 endpos
= regmatch
.endpos
[0];
800 submatch
= first_submatch(®match
);
807 * We found a valid match, now check if there is
808 * another one after it.
809 * If vi-compatible searching, continue at the end
810 * of the match, otherwise continue one position
813 if (vim_strchr(p_cpo
, CPO_SEARCH
) != NULL
)
817 matchcol
= endpos
.col
;
818 /* for empty match: advance one char */
819 if (matchcol
== matchpos
.col
820 && ptr
[matchcol
] != NUL
)
825 (*mb_ptr2len
)(ptr
+ matchcol
);
833 /* Stop when the match is in a next line. */
834 if (matchpos
.lnum
> 0)
836 matchcol
= matchpos
.col
;
837 if (ptr
[matchcol
] != NUL
)
842 (*mb_ptr2len
)(ptr
+ matchcol
);
848 if (ptr
[matchcol
] == NUL
849 || (nmatched
= vim_regexec_multi(®match
,
850 win
, buf
, lnum
+ matchpos
.lnum
,
860 /* Need to get the line pointer again, a
861 * multi-line search may have made it invalid. */
862 ptr
= ml_get_buf(buf
, lnum
+ matchpos
.lnum
, FALSE
);
866 * If there is only a match after the cursor, skip
873 /* With the SEARCH_END option move to the last character
874 * of the match. Don't do it for an empty match, end
875 * should be same as start then. */
876 if (options
& SEARCH_END
&& !(options
& SEARCH_NOOF
)
877 && !(matchpos
.lnum
== endpos
.lnum
878 && matchpos
.col
== endpos
.col
))
880 /* For a match in the first column, set the position
881 * on the NUL in the previous line. */
882 pos
->lnum
= lnum
+ endpos
.lnum
;
883 pos
->col
= endpos
.col
;
886 if (pos
->lnum
> 1) /* just in case */
889 pos
->col
= (colnr_T
)STRLEN(ml_get_buf(buf
,
898 && pos
->lnum
<= buf
->b_ml
.ml_line_count
)
900 ptr
= ml_get_buf(buf
, pos
->lnum
, FALSE
);
901 pos
->col
-= (*mb_head_off
)(ptr
, ptr
+ pos
->col
);
908 pos
->lnum
= lnum
+ matchpos
.lnum
;
909 pos
->col
= matchpos
.col
;
911 #ifdef FEAT_VIRTUALEDIT
916 /* Set variables used for 'incsearch' highlighting. */
917 search_match_lines
= endpos
.lnum
- matchpos
.lnum
;
918 search_match_endcol
= endpos
.col
;
921 line_breakcheck(); /* stop if ctrl-C typed */
925 #ifdef FEAT_SEARCH_EXTRA
926 /* Cancel searching if a character was typed. Used for
927 * 'incsearch'. Don't check too often, that would slowdown
928 * searching too much. */
929 if ((options
& SEARCH_PEEK
)
930 && ((lnum
- pos
->lnum
) & 0x3f) == 0
938 if (loop
&& lnum
== start_pos
.lnum
)
939 break; /* if second loop, stop where started */
941 at_first_line
= FALSE
;
944 * Stop the search if wrapscan isn't set, "stop_lnum" is
945 * specified, after an interrupt, after a match and after looping
948 if (!p_ws
|| stop_lnum
!= 0 || got_int
|| called_emsg
949 #ifdef FEAT_SEARCH_EXTRA
956 * If 'wrapscan' is set we continue at the other end of the file.
957 * If 'shortmess' does not contain 's', we give a message.
958 * This message is also remembered in keep_msg for when the screen
959 * is redrawn. The keep_msg is cleared whenever another message is
962 if (dir
== BACKWARD
) /* start second loop at the other end */
963 lnum
= buf
->b_ml
.ml_line_count
;
966 if (!shortmess(SHM_SEARCH
) && (options
& SEARCH_MSG
))
967 give_warning((char_u
*)_(dir
== BACKWARD
968 ? top_bot_msg
: bot_top_msg
), TRUE
);
970 if (got_int
|| called_emsg
971 #ifdef FEAT_SEARCH_EXTRA
977 while (--count
> 0 && found
); /* stop after count matches or no match */
979 vim_free(regmatch
.regprog
);
981 called_emsg
|= save_called_emsg
;
983 if (!found
) /* did not find it */
987 else if ((options
& SEARCH_MSG
) == SEARCH_MSG
)
990 EMSG2(_(e_patnotf2
), mr_pattern
);
992 EMSG2(_("E384: search hit TOP without match for: %s"),
995 EMSG2(_("E385: search hit BOTTOM without match for: %s"),
1001 /* A pattern like "\n\zs" may go past the last line. */
1002 if (pos
->lnum
> buf
->b_ml
.ml_line_count
)
1004 pos
->lnum
= buf
->b_ml
.ml_line_count
;
1005 pos
->col
= (int)STRLEN(ml_get_buf(buf
, pos
->lnum
, FALSE
));
1010 return submatch
+ 1;
1015 set_search_direction(cdir
)
1018 spats
[0].off
.dir
= cdir
;
1022 set_vv_searchforward()
1024 set_vim_var_nr(VV_SEARCHFORWARD
, (long)(spats
[0].off
.dir
== '/'));
1028 * Return the number of the first subpat that matched.
1036 for (submatch
= 1; ; ++submatch
)
1038 if (rp
->startpos
[submatch
].lnum
>= 0)
1051 # define MIGEMO_QUERY_MAXSIZE 40960
1052 /* Load migemo header */
1053 # ifndef DYNAMIC_MIGEMO
1054 # include <migemo.h>
1055 # else /* DYNAMIC_MIGEMO */
1057 # define MIGEMO_PROC FARPROC
1058 # ifndef DYNAMIC_MIGEMO_DLL
1059 # define DYNAMIC_MIGEMO_DLL "migemo.dll"
1062 # define MIGEMO_OPINDEX_OR 0
1063 # define MIGEMO_OPINDEX_NEST_IN 1
1064 # define MIGEMO_OPINDEX_NEST_OUT 2
1065 # define MIGEMO_OPINDEX_SELECT_IN 3
1066 # define MIGEMO_OPINDEX_SELECT_OUT 4
1067 # define MIGEMO_OPINDEX_NEWLINE 5
1069 typedef struct _migemo migemo
;
1070 typedef int (*MIGEMO_PROC_CHAR2INT
)(unsigned char*, unsigned int*);
1071 typedef int (*MIGEMO_PROC_INT2CHAR
)(unsigned int, unsigned char*);
1072 static HANDLE hDllMigemo
= NULL
;
1073 migemo
* (*dll_migemo_open
)(char*);
1074 void (*dll_migemo_close
)(migemo
*);
1075 unsigned char* (*dll_migemo_query
)(migemo
*, unsigned char*);
1076 void (*dll_migemo_release
)(migemo
*, unsigned char*);
1077 int (*dll_migemo_set_operator
)(migemo
*, int index
, unsigned char* op
);
1078 const unsigned char* (*dll_migemo_get_operator
)(migemo
*, int index
);
1079 void (*dll_migemo_setproc_char2int
)(migemo
*, MIGEMO_PROC_CHAR2INT
);
1080 void (*dll_migemo_setproc_int2char
)(migemo
*, MIGEMO_PROC_INT2CHAR
);
1082 # define migemo_open dll_migemo_open
1083 # define migemo_close dll_migemo_close
1084 # define migemo_query dll_migemo_query
1085 # define migemo_release dll_migemo_release
1086 # define migemo_set_operator dll_migemo_set_operator
1087 # define migemo_get_operator dll_migemo_get_operator
1088 # define migemo_setproc_char2int dll_migemo_setproc_char2int
1089 # define migemo_setproc_int2char dll_migemo_setproc_int2char
1096 FreeLibrary(hDllMigemo
);
1104 static struct { char* name
; MIGEMO_PROC
* ptr
; } migemo_func_table
[] = {
1105 {"migemo_open", (MIGEMO_PROC
*)&dll_migemo_open
},
1106 {"migemo_close", (MIGEMO_PROC
*)&dll_migemo_close
},
1107 {"migemo_query", (MIGEMO_PROC
*)&dll_migemo_query
},
1108 {"migemo_release", (MIGEMO_PROC
*)&dll_migemo_release
},
1109 {"migemo_set_operator", (MIGEMO_PROC
*)&dll_migemo_set_operator
},
1110 {"migemo_get_operator", (MIGEMO_PROC
*)&dll_migemo_get_operator
},
1111 {"migemo_setproc_char2int", (MIGEMO_PROC
*)&dll_migemo_setproc_char2int
},
1112 {"migemo_setproc_int2char", (MIGEMO_PROC
*)&dll_migemo_setproc_int2char
},
1119 if (!(hDllMigemo
= LoadLibraryEx(DYNAMIC_MIGEMO_DLL
, NULL
, 0)))
1121 for (i
= 0; migemo_func_table
[i
].ptr
; ++i
)
1123 if (!(*migemo_func_table
[i
].ptr
= GetProcAddress(hDllMigemo
,
1124 migemo_func_table
[i
].name
)))
1132 # endif /* DYNAMIC_MIGEMO */
1135 vimigemo_char2int(unsigned char* p
, unsigned int* code
)
1137 unsigned int ch
= *p
;
1143 ch
= (*mb_ptr2char
)(p
);
1144 len
= (*mb_ptr2len
)(p
);
1153 vimigemo_int2char(unsigned int code
, unsigned char* buf
)
1158 if (has_mbyte
&& (len
= (*mb_char2len
)(code
)) != 1)
1161 (*mb_char2bytes
)(code
, buf
);
1170 case '.': case '*': case '^': case '$': case '/':
1171 case '[': case ']': case '~':
1177 buf
[len
] = (unsigned char)(code
& 0xFF);
1190 #ifdef DYNAMIC_MIGEMO
1198 static migemo
* migemo_object
= NULL
;
1199 static int migemo_tryload
= 0;
1204 # ifdef DYNAMIC_MIGEMO
1205 if (!dyn_migemo_init())
1208 if (migemo_tryload
|| migemo_object
)
1212 migemo_object
= migemo_open(p_migdict
);
1217 migemo_set_operator(migemo_object
, MIGEMO_OPINDEX_OR
, "\\|");
1218 migemo_set_operator(migemo_object
, MIGEMO_OPINDEX_NEST_IN
, "\\%(");
1219 migemo_set_operator(migemo_object
, MIGEMO_OPINDEX_NEST_OUT
, "\\)");
1220 migemo_set_operator(migemo_object
, MIGEMO_OPINDEX_NEST_OUT
, "\\)");
1221 migemo_set_operator(migemo_object
, MIGEMO_OPINDEX_NEWLINE
, "\\_s*");
1222 migemo_setproc_int2char(migemo_object
, vimigemo_int2char
);
1223 migemo_setproc_char2int(migemo_object
, vimigemo_char2int
);
1227 reset_migemo(int lastcall
)
1230 migemo_close(migemo_object
);
1231 migemo_object
= NULL
;
1233 # ifdef DYNAMIC_MIGEMO
1240 query_migemo(char_u
* str
)
1242 char_u
*retval
= NULL
;
1249 char *query
= migemo_query(migemo_object
, str
);
1253 retval
= vim_strsave(query
);
1254 migemo_release(migemo_object
, query
);
1258 return retval
? retval
: str
;
1262 check_migemo_able_string(char_u
* str
)
1267 /* Disabled because of adding query size limitation. */
1269 if (len
== 1 && vim_strchr("kstnKSTN", str
[0]))
1272 /* TODO: Incomplete method. To be improved. */
1273 if (len
>= 1 && (vim_strchr(str
, '^')))
1275 if (len
>= 2 && !STRNCMP(str
, "\\<", 2))
1277 /* Search for multibyte char */
1282 if ((*mb_ptr2len
)(str
) > 1)
1291 searchit_migemo(win
, buf
, pos
, dir
, str
, count
, options
, pat_use
, stop_lnum
,
1301 linenr_T stop_lnum
; /* stop after this line number when != 0 */
1308 if (str
&& buf
&& STRLEN(p_migdict
) > 0 && check_migemo_able_string(str
))
1314 char_u
*newstr
= NULL
;
1316 /* Remove backslash in str */
1317 if (vim_strchr(str
, '\\') && (newstr
= vim_strsave(str
)))
1319 char_u
*p
, *end
= newstr
+ STRLEN(newstr
);
1321 for (p
= newstr
; p
[0] != NUL
; ++p
)
1323 if ((p
= vim_strchr(p
, '\\')) == NULL
)
1325 mch_memmove(p
, p
+ 1, end
- p
);
1329 query
= migemo_query(migemo_object
, str
);
1330 if (query
&& STRLEN(query
) < MIGEMO_QUERY_MAXSIZE
)
1332 retval
= searchit(win
, buf
, pos
, dir
, query
, count
, options
,
1333 pat_use
, stop_lnum
, tm
);
1337 migemo_release(migemo_object
, query
);
1347 #endif /* USE_MIGEMO */
1350 * Highest level string search function.
1351 * Search for the 'count'th occurrence of pattern 'pat' in direction 'dirc'
1352 * If 'dirc' is 0: use previous dir.
1353 * If 'pat' is NULL or empty : use previous string.
1354 * If 'options & SEARCH_REV' : go in reverse of previous dir.
1355 * If 'options & SEARCH_ECHO': echo the search command and handle options
1356 * If 'options & SEARCH_MSG' : may give error message
1357 * If 'options & SEARCH_OPT' : interpret optional flags
1358 * If 'options & SEARCH_HIS' : put search pattern in history
1359 * If 'options & SEARCH_NOOF': don't add offset to position
1360 * If 'options & SEARCH_MARK': set previous context mark
1361 * If 'options & SEARCH_KEEP': keep previous search pattern
1362 * If 'options & SEARCH_START': accept match at curpos itself
1363 * If 'options & SEARCH_PEEK': check for typed char, cancel search
1365 * Careful: If spats[0].off.line == TRUE and spats[0].off.off == 0 this
1366 * makes the movement linewise without moving the match position.
1368 * return 0 for failure, 1 for found, 2 for found and line offset added
1371 do_search(oap
, dirc
, pat
, count
, options
, tm
)
1372 oparg_T
*oap
; /* can be NULL */
1373 int dirc
; /* '/' or '?' */
1377 proftime_T
*tm
; /* timeout limit or NULL */
1379 pos_T pos
; /* position of the last match */
1381 struct soffset old_off
;
1382 int retval
; /* Return value */
1386 char_u
*strcopy
= NULL
;
1390 * A line offset is not remembered, this is vi compatible.
1392 if (spats
[0].off
.line
&& vim_strchr(p_cpo
, CPO_LINEOFF
) != NULL
)
1394 spats
[0].off
.line
= FALSE
;
1395 spats
[0].off
.off
= 0;
1399 * Save the values for when (options & SEARCH_KEEP) is used.
1400 * (there is no "if ()" around this because gcc wants them initialized)
1402 old_off
= spats
[0].off
;
1404 pos
= curwin
->w_cursor
; /* start searching at the cursor position */
1407 * Find out the direction of the search.
1410 dirc
= spats
[0].off
.dir
;
1413 spats
[0].off
.dir
= dirc
;
1414 #if defined(FEAT_EVAL)
1415 set_vv_searchforward();
1418 if (options
& SEARCH_REV
)
1421 /* There is a bug in the Visual C++ 2.2 compiler which means that
1422 * dirc always ends up being '/' */
1423 dirc
= (dirc
== '/') ? '?' : '/';
1433 /* If the cursor is in a closed fold, don't find another match in the same
1437 if (hasFolding(pos
.lnum
, NULL
, &pos
.lnum
))
1438 pos
.col
= MAXCOL
- 2; /* avoid overflow when adding 1 */
1442 if (hasFolding(pos
.lnum
, &pos
.lnum
, NULL
))
1447 #ifdef FEAT_SEARCH_EXTRA
1449 * Turn 'hlsearch' highlighting back on.
1451 if (no_hlsearch
&& !(options
& SEARCH_KEEP
))
1453 redraw_all_later(SOME_VALID
);
1454 no_hlsearch
= FALSE
;
1459 * Repeat the search when pattern followed by ';', e.g. "/foo/;?bar".
1465 /* use previous pattern */
1466 if (pat
== NULL
|| *pat
== NUL
|| *pat
== dirc
)
1468 if (spats
[RE_SEARCH
].pat
== NULL
) /* no previous pattern */
1470 EMSG(_(e_noprevre
));
1474 /* make search_regcomp() use spats[RE_SEARCH].pat */
1475 searchstr
= (char_u
*)"";
1478 if (pat
!= NULL
&& *pat
!= NUL
) /* look for (new) offset */
1481 * Find end of regular expression.
1482 * If there is a matching '/' or '?', toss it.
1485 p
= skip_regexp(pat
, dirc
, (int)p_magic
, &strcopy
);
1488 /* made a copy of "pat" to change "\?" to "?" */
1489 searchcmdlen
+= (int)(STRLEN(pat
) - STRLEN(strcopy
));
1491 searchstr
= strcopy
;
1495 dircp
= p
; /* remember where we put the NUL */
1498 spats
[0].off
.line
= FALSE
;
1499 spats
[0].off
.end
= FALSE
;
1500 spats
[0].off
.off
= 0;
1502 * Check for a line offset or a character offset.
1503 * For get_address (echo off) we don't check for a character
1504 * offset, because it is meaningless and the 's' could be a
1505 * substitute command.
1507 if (*p
== '+' || *p
== '-' || VIM_ISDIGIT(*p
))
1508 spats
[0].off
.line
= TRUE
;
1509 else if ((options
& SEARCH_OPT
) &&
1510 (*p
== 'e' || *p
== 's' || *p
== 'b'))
1512 if (*p
== 'e') /* end */
1513 spats
[0].off
.end
= SEARCH_END
;
1516 if (VIM_ISDIGIT(*p
) || *p
== '+' || *p
== '-') /* got an offset */
1518 /* 'nr' or '+nr' or '-nr' */
1519 if (VIM_ISDIGIT(*p
) || VIM_ISDIGIT(*(p
+ 1)))
1520 spats
[0].off
.off
= atol((char *)p
);
1521 else if (*p
== '-') /* single '-' */
1522 spats
[0].off
.off
= -1;
1523 else /* single '+' */
1524 spats
[0].off
.off
= 1;
1526 while (VIM_ISDIGIT(*p
)) /* skip number */
1530 /* compute length of search command for get_address() */
1531 searchcmdlen
+= (int)(p
- pat
);
1533 pat
= p
; /* put pat after search command */
1536 if ((options
& SEARCH_ECHO
) && messaging()
1537 && !cmd_silent
&& msg_silent
== 0)
1542 if (*searchstr
== NUL
)
1543 p
= spats
[last_idx
].pat
;
1546 msgbuf
= alloc((unsigned)(STRLEN(p
) + 40));
1551 if (enc_utf8
&& utf_iscomposing(utf_ptr2char(p
)))
1553 /* Use a space to draw the composing char on. */
1555 STRCPY(msgbuf
+ 2, p
);
1559 STRCPY(msgbuf
+ 1, p
);
1560 if (spats
[0].off
.line
|| spats
[0].off
.end
|| spats
[0].off
.off
)
1562 p
= msgbuf
+ STRLEN(msgbuf
);
1564 if (spats
[0].off
.end
)
1566 else if (!spats
[0].off
.line
)
1568 if (spats
[0].off
.off
> 0 || spats
[0].off
.line
)
1570 if (spats
[0].off
.off
!= 0 || spats
[0].off
.line
)
1571 sprintf((char *)p
, "%ld", spats
[0].off
.off
);
1577 trunc
= msg_strtrunc(msgbuf
, FALSE
);
1579 #ifdef FEAT_RIGHTLEFT
1580 /* The search pattern could be shown on the right in rightleft
1581 * mode, but the 'ruler' and 'showcmd' area use it too, thus
1582 * it would be blanked out again very soon. Show it on the
1583 * left, but do reverse the text. */
1584 if (curwin
->w_p_rl
&& *curwin
->w_p_rlc
== 's')
1588 r
= reverse_text(trunc
!= NULL
? trunc
: msgbuf
);
1598 msg_outtrans(trunc
);
1602 msg_outtrans(msgbuf
);
1609 msg_nowait
= TRUE
; /* don't wait for this message */
1614 * If there is a character offset, subtract it from the current
1615 * position, so we don't get stuck at "?pat?e+2" or "/pat/s-2".
1616 * Skip this if pos.col is near MAXCOL (closed fold).
1617 * This is not done for a line offset, because then we would not be vi
1620 if (!spats
[0].off
.line
&& spats
[0].off
.off
&& pos
.col
< MAXCOL
- 2)
1622 if (spats
[0].off
.off
> 0)
1624 for (c
= spats
[0].off
.off
; c
; --c
)
1625 if (decl(&pos
) == -1)
1627 if (c
) /* at start of buffer */
1629 pos
.lnum
= 0; /* allow lnum == 0 here */
1635 for (c
= spats
[0].off
.off
; c
; ++c
)
1636 if (incl(&pos
) == -1)
1638 if (c
) /* at end of buffer */
1640 pos
.lnum
= curbuf
->b_ml
.ml_line_count
+ 1;
1646 #ifdef FEAT_FKMAP /* when in Farsi mode, reverse the character flow */
1647 if (p_altkeymap
&& curwin
->w_p_rl
)
1648 lrFswap(searchstr
,0);
1654 if (options
& SEARCH_MIGEMO
)
1655 c
= searchit_migemo(
1656 curwin
, curbuf
, &pos
,
1657 dirc
== '/' ? FORWARD
: BACKWARD
,
1658 searchstr
, count
, spats
[0].off
.end
+ (options
&
1659 (SEARCH_KEEP
+ SEARCH_PEEK
+ SEARCH_HIS
1660 + SEARCH_MSG
+ SEARCH_START
1661 + ((pat
!= NULL
&& *pat
== ';') ?
1663 RE_LAST
, (linenr_T
)0, tm
, &did_migemo
);
1665 #endif /* USE_MIGEMO */
1666 c
= searchit(curwin
, curbuf
, &pos
, dirc
== '/' ? FORWARD
: BACKWARD
,
1667 searchstr
, count
, spats
[0].off
.end
+ (options
&
1668 (SEARCH_KEEP
+ SEARCH_PEEK
+ SEARCH_HIS
1669 + SEARCH_MSG
+ SEARCH_START
1670 + ((pat
!= NULL
&& *pat
== ';') ? 0 : SEARCH_NOOF
))),
1671 RE_LAST
, (linenr_T
)0, tm
);
1674 #endif /* USE_MIGEMO */
1677 *dircp
= dirc
; /* restore second '/' or '?' for normal_cmd() */
1683 if (spats
[0].off
.end
&& oap
!= NULL
)
1684 oap
->inclusive
= TRUE
; /* 'e' includes last character */
1686 retval
= 1; /* pattern found */
1689 * Add character and/or line offset
1691 if (!(options
& SEARCH_NOOF
) || (pat
!= NULL
&& *pat
== ';'))
1693 if (spats
[0].off
.line
) /* Add the offset to the line number. */
1695 c
= pos
.lnum
+ spats
[0].off
.off
;
1698 else if (c
> curbuf
->b_ml
.ml_line_count
)
1699 pos
.lnum
= curbuf
->b_ml
.ml_line_count
;
1704 retval
= 2; /* pattern found, line offset added */
1706 else if (pos
.col
< MAXCOL
- 2) /* just in case */
1708 /* to the right, check for end of file */
1709 c
= spats
[0].off
.off
;
1713 if (incl(&pos
) == -1)
1716 /* to the left, check for start of file */
1720 if (decl(&pos
) == -1)
1727 * The search command can be followed by a ';' to do another search.
1728 * For example: "/pat/;/foo/+3;?bar"
1729 * This is like doing another search command, except:
1730 * - The remembered direction '/' or '?' is from the first search.
1731 * - When an error happens the cursor isn't moved at all.
1732 * Don't do this when called by get_address() (it handles ';' itself).
1734 if (!(options
& SEARCH_OPT
) || pat
== NULL
|| *pat
!= ';')
1738 if (dirc
!= '?' && dirc
!= '/')
1741 EMSG(_("E386: Expected '?' or '/' after ';'"));
1747 if (options
& SEARCH_MARK
)
1749 curwin
->w_cursor
= pos
;
1750 curwin
->w_set_curswant
= TRUE
;
1753 if (options
& SEARCH_KEEP
)
1754 spats
[0].off
= old_off
;
1760 #if defined(FEAT_INS_EXPAND) || defined(PROTO)
1762 * search_for_exact_line(buf, pos, dir, pat)
1764 * Search for a line starting with the given pattern (ignoring leading
1765 * white-space), starting from pos and going in direction dir. pos will
1766 * contain the position of the match found. Blank lines match only if
1767 * ADDING is set. if p_ic is set then the pattern must be in lowercase.
1768 * Return OK for success, or FAIL if no line found.
1771 search_for_exact_line(buf
, pos
, dir
, pat
)
1781 if (buf
->b_ml
.ml_line_count
== 0)
1790 pos
->lnum
= buf
->b_ml
.ml_line_count
;
1791 if (!shortmess(SHM_SEARCH
))
1792 give_warning((char_u
*)_(top_bot_msg
), TRUE
);
1800 else if (pos
->lnum
> buf
->b_ml
.ml_line_count
)
1805 if (!shortmess(SHM_SEARCH
))
1806 give_warning((char_u
*)_(bot_top_msg
), TRUE
);
1814 if (pos
->lnum
== start
)
1818 ptr
= ml_get_buf(buf
, pos
->lnum
, FALSE
);
1820 pos
->col
= (colnr_T
) (p
- ptr
);
1822 /* when adding lines the matching line may be empty but it is not
1823 * ignored because we are interested in the next line -- Acevedo */
1824 if ((compl_cont_status
& CONT_ADDING
)
1825 && !(compl_cont_status
& CONT_SOL
))
1827 if ((p_ic
? MB_STRICMP(p
, pat
) : STRCMP(p
, pat
)) == 0)
1830 else if (*p
!= NUL
) /* ignore empty lines */
1831 { /* expanding lines or words */
1832 if ((p_ic
? MB_STRNICMP(p
, pat
, compl_length
)
1833 : STRNCMP(p
, pat
, compl_length
)) == 0)
1839 #endif /* FEAT_INS_EXPAND */
1842 * Character Searches
1846 * Search for a character in a line. If "t_cmd" is FALSE, move to the
1847 * position of the character, otherwise move to just before the char.
1848 * Do this "cap->count1" times.
1849 * Return FAIL or OK.
1856 int c
= cap
->nchar
; /* char to search for */
1857 int dir
= cap
->arg
; /* TRUE for searching forward */
1858 long count
= cap
->count1
; /* repeat count */
1859 static int lastc
= NUL
; /* last character searched for */
1860 static int lastcdir
; /* last direction of character search */
1861 static int last_t_cmd
; /* last search t_cmd */
1866 static char_u bytes
[MB_MAXBYTES
];
1867 static int bytelen
= 1; /* >1 for multi-byte char */
1870 if (c
!= NUL
) /* normal search: remember args for repeat */
1872 if (!KeyStuffed
) /* don't remember when redoing */
1878 bytelen
= (*mb_char2bytes
)(c
, bytes
);
1879 if (cap
->ncharC1
!= 0)
1881 bytelen
+= (*mb_char2bytes
)(cap
->ncharC1
, bytes
+ bytelen
);
1882 if (cap
->ncharC2
!= 0)
1883 bytelen
+= (*mb_char2bytes
)(cap
->ncharC2
, bytes
+ bytelen
);
1888 else /* repeat previous search */
1892 if (dir
) /* repeat in opposite direction */
1898 /* For multi-byte re-use last bytes[] and bytelen. */
1901 if (dir
== BACKWARD
)
1902 cap
->oap
->inclusive
= FALSE
;
1904 cap
->oap
->inclusive
= TRUE
;
1906 p
= ml_get_curline();
1907 col
= curwin
->w_cursor
.col
;
1908 len
= (int)STRLEN(p
);
1919 col
+= (*mb_ptr2len
)(p
+ col
);
1927 col
-= (*mb_head_off
)(p
, p
+ col
- 1) + 1;
1936 if (vim_memcmp(p
+ col
, bytes
, bytelen
) == 0)
1946 if ((col
+= dir
) < 0 || col
>= len
)
1956 /* backup to before the character (possibly double-byte) */
1962 /* Landed on the search char which is bytelen long */
1965 /* To previous char, which may be multi-byte. */
1966 col
-= (*mb_head_off
)(p
, p
+ col
);
1970 curwin
->w_cursor
.col
= col
;
1980 * findmatch - find the matching paren or brace
1982 * Improvement over vi: Braces inside quotes are ignored.
1985 findmatch(oap
, initc
)
1989 return findmatchlimit(oap
, initc
, 0, 0);
1993 * Return TRUE if the character before "linep[col]" equals "ch".
1994 * Return FALSE if "col" is zero.
1995 * Update "*prevcol" to the column of the previous character, unless "prevcol"
1997 * Handles multibyte string correctly.
2000 check_prevcol(linep
, col
, ch
, prevcol
)
2008 if (col
> 0 && has_mbyte
)
2009 col
-= (*mb_head_off
)(linep
, linep
+ col
);
2013 return (col
>= 0 && linep
[col
] == ch
) ? TRUE
: FALSE
;
2017 * findmatchlimit -- find the matching paren or brace, if it exists within
2018 * maxtravel lines of here. A maxtravel of 0 means search until falling off
2019 * the edge of the file.
2021 * "initc" is the character to find a match for. NUL means to find the
2022 * character at or after the cursor.
2024 * flags: FM_BACKWARD search backwards (when initc is '/', '*' or '#')
2025 * FM_FORWARD search forwards (when initc is '/', '*' or '#')
2026 * FM_BLOCKSTOP stop at start/end of block ({ or } in column 0)
2027 * FM_SKIPCOMM skip comments (not implemented yet!)
2029 * "oap" is only used to set oap->motion_type for a linewise motion, it be
2034 findmatchlimit(oap
, initc
, flags
, maxtravel
)
2040 static pos_T pos
; /* current search position */
2041 int findc
= 0; /* matching brace */
2043 int count
= 0; /* cumulative number of braces */
2044 int backwards
= FALSE
; /* init for gcc */
2045 int inquote
= FALSE
; /* TRUE when inside quotes */
2046 char_u
*linep
; /* pointer to current line */
2048 int do_quotes
; /* check for quotes in current line */
2049 int at_start
; /* do_quotes value at start position */
2050 int hash_dir
= 0; /* Direction searched for # things */
2051 int comment_dir
= 0; /* Direction searched for comments */
2052 pos_T match_pos
; /* Where last slash-star was found */
2053 int start_in_quotes
; /* start position is in quotes */
2054 int traveled
= 0; /* how far we've searched so far */
2055 int ignore_cend
= FALSE
; /* ignore comment end */
2056 int cpo_match
; /* vi compatible matching */
2057 int cpo_bsl
; /* don't recognize backslashes */
2058 int match_escaped
= 0; /* search for escaped match */
2059 int dir
; /* Direction to search */
2060 int comment_col
= MAXCOL
; /* start of / / comment */
2062 int lispcomm
= FALSE
; /* inside of Lisp-style comment */
2063 int lisp
= curbuf
->b_p_lisp
; /* engage Lisp-specific hacks ;) */
2066 pos
= curwin
->w_cursor
;
2067 linep
= ml_get(pos
.lnum
);
2069 cpo_match
= (vim_strchr(p_cpo
, CPO_MATCH
) != NULL
);
2070 cpo_bsl
= (vim_strchr(p_cpo
, CPO_MATCHBSL
) != NULL
);
2072 /* Direction to search when initc is '/', '*' or '#' */
2073 if (flags
& FM_BACKWARD
)
2075 else if (flags
& FM_FORWARD
)
2081 * if initc given, look in the table for the matching character
2082 * '/' and '*' are special cases: look for start or end of comment.
2083 * When '/' is used, we ignore running backwards into an star-slash, for
2084 * "[*" command, we just want to find any comment.
2086 if (initc
== '/' || initc
== '*')
2091 backwards
= (dir
== FORWARD
) ? FALSE
: TRUE
;
2094 else if (initc
!= '#' && initc
!= NUL
)
2096 /* 'matchpairs' is "x:y,x:y" */
2097 for (ptr
= curbuf
->b_p_mps
; *ptr
; ptr
+= 2)
2117 if (!findc
) /* invalid initc! */
2121 * Either initc is '#', or no initc was given and we need to look under the
2133 * initc was not given, must look for something to match under
2134 * or near the cursor.
2135 * Only check for special things when 'cpo' doesn't have '%'.
2139 /* Are we before or at #if, #else etc.? */
2140 ptr
= skipwhite(linep
);
2141 if (*ptr
== '#' && pos
.col
<= (colnr_T
)(ptr
- linep
))
2143 ptr
= skipwhite(ptr
+ 1);
2144 if ( STRNCMP(ptr
, "if", 2) == 0
2145 || STRNCMP(ptr
, "endif", 5) == 0
2146 || STRNCMP(ptr
, "el", 2) == 0)
2150 /* Are we on a comment? */
2151 else if (linep
[pos
.col
] == '/')
2153 if (linep
[pos
.col
+ 1] == '*')
2155 comment_dir
= FORWARD
;
2159 else if (pos
.col
> 0 && linep
[pos
.col
- 1] == '*')
2161 comment_dir
= BACKWARD
;
2166 else if (linep
[pos
.col
] == '*')
2168 if (linep
[pos
.col
+ 1] == '/')
2170 comment_dir
= BACKWARD
;
2173 else if (pos
.col
> 0 && linep
[pos
.col
- 1] == '/')
2175 comment_dir
= FORWARD
;
2182 * If we are not on a comment or the # at the start of a line, then
2183 * look for brace anywhere on this line after the cursor.
2185 if (!hash_dir
&& !comment_dir
)
2188 * Find the brace under or after the cursor.
2189 * If beyond the end of the line, use the last character in
2192 if (linep
[pos
.col
] == NUL
&& pos
.col
)
2196 initc
= linep
[pos
.col
];
2200 for (ptr
= curbuf
->b_p_mps
; *ptr
; ++ptr
)
2222 pos
.col
+= (*mb_ptr2len
)(linep
+ pos
.col
);
2229 /* no brace in the line, maybe use " #if" then */
2230 if (!cpo_match
&& *skipwhite(linep
) == '#')
2237 int col
, bslcnt
= 0;
2239 /* Set "match_escaped" if there are an odd number of
2241 for (col
= pos
.col
; check_prevcol(linep
, col
, '\\', &col
);)
2243 match_escaped
= (bslcnt
& 1);
2250 * Look for matching #if, #else, #elif, or #endif
2253 oap
->motion_type
= MLINE
; /* Linewise for this case only */
2256 ptr
= skipwhite(skipwhite(linep
) + 1);
2257 if (STRNCMP(ptr
, "if", 2) == 0 || STRNCMP(ptr
, "el", 2) == 0)
2259 else if (STRNCMP(ptr
, "endif", 5) == 0)
2269 if (pos
.lnum
== curbuf
->b_ml
.ml_line_count
)
2272 else if (pos
.lnum
== 1)
2274 pos
.lnum
+= hash_dir
;
2275 linep
= ml_get(pos
.lnum
);
2276 line_breakcheck(); /* check for CTRL-C typed */
2277 ptr
= skipwhite(linep
);
2280 pos
.col
= (colnr_T
) (ptr
- linep
);
2281 ptr
= skipwhite(ptr
+ 1);
2284 if (STRNCMP(ptr
, "if", 2) == 0)
2286 else if (STRNCMP(ptr
, "el", 2) == 0)
2291 else if (STRNCMP(ptr
, "endif", 5) == 0)
2300 if (STRNCMP(ptr
, "if", 2) == 0)
2306 else if (initc
== '#' && STRNCMP(ptr
, "el", 2) == 0)
2311 else if (STRNCMP(ptr
, "endif", 5) == 0)
2319 #ifdef FEAT_RIGHTLEFT
2320 /* This is just guessing: when 'rightleft' is set, search for a matching
2321 * paren/brace in the other direction. */
2322 if (curwin
->w_p_rl
&& vim_strchr((char_u
*)"()[]{}<>", initc
) != NULL
)
2323 backwards
= !backwards
;
2327 start_in_quotes
= MAYBE
;
2328 clearpos(&match_pos
);
2330 /* backward search: Check if this line contains a single-line comment */
2331 if ((backwards
&& comment_dir
)
2336 comment_col
= check_linecomment(linep
);
2338 if (lisp
&& comment_col
!= MAXCOL
&& pos
.col
> (colnr_T
)comment_col
)
2339 lispcomm
= TRUE
; /* find match inside this comment */
2344 * Go to the next position, forward or backward. We could use
2345 * inc() and dec() here, but that is much slower
2350 /* char to match is inside of comment, don't search outside */
2351 if (lispcomm
&& pos
.col
< (colnr_T
)comment_col
)
2354 if (pos
.col
== 0) /* at start of line, go to prev. one */
2356 if (pos
.lnum
== 1) /* start of file */
2360 if (maxtravel
> 0 && ++traveled
> maxtravel
)
2363 linep
= ml_get(pos
.lnum
);
2364 pos
.col
= (colnr_T
)STRLEN(linep
); /* pos.col on trailing NUL */
2368 /* Check if this line contains a single-line comment */
2374 comment_col
= check_linecomment(linep
);
2377 if (lisp
&& comment_col
!= MAXCOL
)
2378 pos
.col
= comment_col
;
2386 pos
.col
-= (*mb_head_off
)(linep
, linep
+ pos
.col
);
2390 else /* forward search */
2392 if (linep
[pos
.col
] == NUL
2393 /* at end of line, go to next one */
2395 /* don't search for match in comment */
2396 || (lisp
&& comment_col
!= MAXCOL
2397 && pos
.col
== (colnr_T
)comment_col
)
2401 if (pos
.lnum
== curbuf
->b_ml
.ml_line_count
/* end of file */
2403 /* line is exhausted and comment with it,
2404 * don't search for match in code */
2411 if (maxtravel
&& traveled
++ > maxtravel
)
2414 linep
= ml_get(pos
.lnum
);
2419 if (lisp
) /* find comment pos in new line */
2420 comment_col
= check_linecomment(linep
);
2427 pos
.col
+= (*mb_ptr2len
)(linep
+ pos
.col
);
2435 * If FM_BLOCKSTOP given, stop at a '{' or '}' in column 0.
2437 if (pos
.col
== 0 && (flags
& FM_BLOCKSTOP
) &&
2438 (linep
[0] == '{' || linep
[0] == '}'))
2440 if (linep
[0] == findc
&& count
== 0) /* match! */
2442 break; /* out of scope */
2447 /* Note: comments do not nest, and we ignore quotes in them */
2448 /* TODO: ignore comment brackets inside strings */
2449 if (comment_dir
== FORWARD
)
2451 if (linep
[pos
.col
] == '*' && linep
[pos
.col
+ 1] == '/')
2457 else /* Searching backwards */
2460 * A comment may contain / * or / /, it may also start or end
2461 * with / * /. Ignore a / * after / /.
2465 else if ( linep
[pos
.col
- 1] == '/'
2466 && linep
[pos
.col
] == '*'
2467 && (int)pos
.col
< comment_col
)
2473 else if (linep
[pos
.col
- 1] == '*' && linep
[pos
.col
] == '/')
2477 else if (pos
.col
> 1 && linep
[pos
.col
- 2] == '/'
2478 && (int)pos
.col
<= comment_col
)
2480 else if (ignore_cend
)
2491 * If smart matching ('cpoptions' does not contain '%'), braces inside
2492 * of quotes are ignored, but only if there is an even number of
2493 * quotes in the line.
2497 else if (do_quotes
== -1)
2500 * Count the number of quotes in the line, skipping \" and '"'.
2501 * Watch out for "\\".
2503 at_start
= do_quotes
;
2504 for (ptr
= linep
; *ptr
; ++ptr
)
2506 if (ptr
== linep
+ pos
.col
+ backwards
)
2507 at_start
= (do_quotes
& 1);
2509 && (ptr
== linep
|| ptr
[-1] != '\'' || ptr
[1] != '\''))
2511 if (*ptr
== '\\' && ptr
[1] != NUL
)
2514 do_quotes
&= 1; /* result is 1 with even number of quotes */
2517 * If we find an uneven count, check current line and previous
2518 * one for a '\' at the end.
2523 if (ptr
[-1] == '\\')
2526 if (start_in_quotes
== MAYBE
)
2528 /* Do we need to use at_start here? */
2530 start_in_quotes
= TRUE
;
2537 ptr
= ml_get(pos
.lnum
- 1);
2538 if (*ptr
&& *(ptr
+ STRLEN(ptr
) - 1) == '\\')
2541 if (start_in_quotes
== MAYBE
)
2545 start_in_quotes
= TRUE
;
2547 else if (!backwards
)
2551 /* ml_get() only keeps one line, need to get linep again */
2552 linep
= ml_get(pos
.lnum
);
2556 if (start_in_quotes
== MAYBE
)
2557 start_in_quotes
= FALSE
;
2560 * If 'smartmatch' is set:
2561 * Things inside quotes are ignored by setting 'inquote'. If we
2562 * find a quote without a preceding '\' invert 'inquote'. At the
2563 * end of a line not ending in '\' we reset 'inquote'.
2565 * In lines with an uneven number of quotes (without preceding '\')
2566 * we do not know which part to ignore. Therefore we only set
2567 * inquote if the number of quotes in a line is even, unless this
2568 * line or the previous one ends in a '\'. Complicated, isn't it?
2570 switch (c
= linep
[pos
.col
])
2573 /* at end of line without trailing backslash, reset inquote */
2574 if (pos
.col
== 0 || linep
[pos
.col
- 1] != '\\')
2577 start_in_quotes
= FALSE
;
2582 /* a quote that is preceded with an odd number of backslashes is
2588 for (col
= pos
.col
- 1; col
>= 0; --col
)
2589 if (linep
[col
] != '\\')
2591 if ((((int)pos
.col
- 1 - col
) & 1) == 0)
2594 start_in_quotes
= FALSE
;
2600 * If smart matching ('cpoptions' does not contain '%'):
2601 * Skip things in single quotes: 'x' or '\x'. Be careful for single
2602 * single quotes, eg jon's. Things like '\233' or '\x3f' are not
2603 * skipped, there is never a brace in them.
2604 * Ignore this when finding matches for `'.
2607 if (!cpo_match
&& initc
!= '\'' && findc
!= '\'')
2613 if (linep
[pos
.col
- 2] == '\'')
2618 else if (linep
[pos
.col
- 2] == '\\' &&
2619 pos
.col
> 2 && linep
[pos
.col
- 3] == '\'')
2626 else if (linep
[pos
.col
+ 1]) /* forward search */
2628 if (linep
[pos
.col
+ 1] == '\\' &&
2629 linep
[pos
.col
+ 2] && linep
[pos
.col
+ 3] == '\'')
2634 else if (linep
[pos
.col
+ 2] == '\'')
2646 * For Lisp skip over backslashed (), {} and [].
2647 * (actually, we skip #\( et al)
2649 if (curbuf
->b_p_lisp
2650 && vim_strchr((char_u
*)"(){}[]", c
) != NULL
2652 && check_prevcol(linep
, pos
.col
, '\\', NULL
)
2653 && check_prevcol(linep
, pos
.col
- 1, '#', NULL
))
2657 /* Check for match outside of quotes, and inside of
2658 * quotes when the start is also inside of quotes. */
2659 if ((!inquote
|| start_in_quotes
== TRUE
)
2660 && (c
== initc
|| c
== findc
))
2662 int col
, bslcnt
= 0;
2666 for (col
= pos
.col
; check_prevcol(linep
, col
, '\\', &col
);)
2669 /* Only accept a match when 'M' is in 'cpo' or when escaping
2670 * is what we expect. */
2671 if (cpo_bsl
|| (bslcnt
& 1) == match_escaped
)
2686 if (comment_dir
== BACKWARD
&& count
> 0)
2691 return (pos_T
*)NULL
; /* never found it */
2695 * Check if line[] contains a / / comment.
2696 * Return MAXCOL if not, otherwise return the column.
2697 * TODO: skip strings.
2700 check_linecomment(line
)
2707 /* skip Lispish one-line comments */
2708 if (curbuf
->b_p_lisp
)
2710 if (vim_strchr(p
, ';') != NULL
) /* there may be comments */
2712 int instr
= FALSE
; /* inside of string */
2714 p
= line
; /* scan from start */
2715 while ((p
= vim_strpbrk(p
, (char_u
*)"\";")) != NULL
)
2721 if (*(p
- 1) != '\\') /* skip escaped quote */
2724 else if (p
== line
|| ((p
- line
) >= 2
2726 && *(p
- 1) != '\\' && *(p
- 2) != '#'))
2729 else if (!instr
&& ((p
- line
) < 2
2730 || (*(p
- 1) != '\\' && *(p
- 2) != '#')))
2740 while ((p
= vim_strchr(p
, '/')) != NULL
)
2742 /* accept a double /, unless it's preceded with * and followed by *,
2743 * because * / / * is an end and start of a C comment */
2744 if (p
[1] == '/' && (p
== line
|| p
[-1] != '*' || p
[2] != '*'))
2751 return (int)(p
- line
);
2755 * Move cursor briefly to character matching the one under the cursor.
2756 * Used for Insert mode and "r" command.
2757 * Show the match only if it is visible on the screen.
2758 * If there isn't a match, then beep.
2762 int c
; /* char to show match for */
2764 pos_T
*lpos
, save_cursor
;
2772 colnr_T save_dollar_vcol
;
2776 * Only show match for chars in the 'matchpairs' option.
2778 /* 'matchpairs' is "x:y,x:y" */
2779 for (p
= curbuf
->b_p_mps
; *p
!= NUL
; p
+= 2)
2781 #ifdef FEAT_RIGHTLEFT
2782 if (*p
== c
&& (curwin
->w_p_rl
^ p_ri
))
2787 #ifdef FEAT_RIGHTLEFT
2788 && !(curwin
->w_p_rl
^ p_ri
)
2796 if ((lpos
= findmatch(NULL
, NUL
)) == NULL
) /* no match, so beep */
2798 else if (lpos
->lnum
>= curwin
->w_topline
)
2800 if (!curwin
->w_p_wrap
)
2801 getvcol(curwin
, lpos
, NULL
, &vcol
, NULL
);
2802 if (curwin
->w_p_wrap
|| (vcol
>= curwin
->w_leftcol
2803 && vcol
< curwin
->w_leftcol
+ W_WIDTH(curwin
)))
2805 mpos
= *lpos
; /* save the pos, update_screen() may change it */
2806 save_cursor
= curwin
->w_cursor
;
2809 /* Handle "$" in 'cpo': If the ')' is typed on top of the "$",
2810 * stop displaying the "$". */
2811 if (dollar_vcol
> 0 && dollar_vcol
== curwin
->w_virtcol
)
2813 ++curwin
->w_virtcol
; /* do display ')' just before "$" */
2814 update_screen(VALID
); /* show the new char first */
2816 save_dollar_vcol
= dollar_vcol
;
2820 ui_cursor_shape(); /* may show different cursor shape */
2822 curwin
->w_cursor
= mpos
; /* move to matching char */
2823 p_so
= 0; /* don't use 'scrolloff' here */
2824 p_siso
= 0; /* don't use 'sidescrolloff' here */
2827 cursor_on(); /* make sure that the cursor is shown */
2832 gui_update_cursor(TRUE
, FALSE
);
2836 /* Restore dollar_vcol(), because setcursor() may call curs_rows()
2837 * which resets it if the matching position is in a previous line
2838 * and has a higher column number. */
2839 dollar_vcol
= save_dollar_vcol
;
2842 * brief pause, unless 'm' is present in 'cpo' and a character is
2845 if (vim_strchr(p_cpo
, CPO_SHOWMATCH
) != NULL
)
2846 ui_delay(p_mat
* 100L, TRUE
);
2847 else if (!char_avail())
2848 ui_delay(p_mat
* 100L, FALSE
);
2849 curwin
->w_cursor
= save_cursor
; /* restore cursor position */
2854 ui_cursor_shape(); /* may show different cursor shape */
2861 * findsent(dir, count) - Find the start of the next sentence in direction
2862 * "dir" Sentences are supposed to end in ".", "!" or "?" followed by white
2863 * space or a line break. Also stop at an empty line.
2864 * Return OK if the next sentence was found.
2867 findsent(dir
, count
)
2873 int (*func
) __ARGS((pos_T
*));
2875 int noskip
= FALSE
; /* do not skip blanks */
2879 pos
= curwin
->w_cursor
;
2888 * if on an empty line, skip upto a non-empty line
2890 if (gchar_pos(&pos
) == NUL
)
2893 if ((*func
)(&pos
) == -1)
2895 while (gchar_pos(&pos
) == NUL
);
2900 * if on the start of a paragraph or a section and searching forward,
2901 * go to the next line
2903 else if (dir
== FORWARD
&& pos
.col
== 0 &&
2904 startPS(pos
.lnum
, NUL
, FALSE
))
2906 if (pos
.lnum
== curbuf
->b_ml
.ml_line_count
)
2911 else if (dir
== BACKWARD
)
2914 /* go back to the previous non-blank char */
2916 while ((c
= gchar_pos(&pos
)) == ' ' || c
== '\t' ||
2917 (dir
== BACKWARD
&& vim_strchr((char_u
*)".!?)]\"'", c
) != NULL
)
2919 || (dir
== BACKWARD
&& (*mb_char2len
)(c
) > 1
2920 && mb_get_class(ml_get_pos(&pos
)) == 1)
2924 if (vim_strchr((char_u
*)".!?", c
) != NULL
)
2926 /* Only skip over a '.', '!' and '?' once. */
2931 if (decl(&pos
) == -1)
2933 /* when going forward: Stop in front of empty line */
2934 if (lineempty(pos
.lnum
) && dir
== FORWARD
)
2941 /* remember the line where the search started */
2942 startlnum
= pos
.lnum
;
2943 cpo_J
= vim_strchr(p_cpo
, CPO_ENDOFSENT
) != NULL
;
2945 for (;;) /* find end of sentence */
2947 c
= gchar_pos(&pos
);
2948 if (c
== NUL
|| (pos
.col
== 0 && startPS(pos
.lnum
, NUL
, FALSE
)))
2950 if (dir
== BACKWARD
&& pos
.lnum
!= startlnum
)
2954 if (c
== '.' || c
== '!' || c
== '?')
2958 if ((c
= inc(&tpos
)) == -1)
2960 while (vim_strchr((char_u
*)")]\"'", c
= gchar_pos(&tpos
))
2962 if (c
== -1 || (!cpo_J
&& (c
== ' ' || c
== '\t')) || c
== NUL
2963 || (cpo_J
&& (c
== ' ' && inc(&tpos
) >= 0
2964 && gchar_pos(&tpos
) == ' ')))
2967 if (gchar_pos(&pos
) == NUL
) /* skip NUL at EOL */
2973 if (has_mbyte
&& (*mb_char2len
)(c
) > 1
2974 && mb_get_class(ml_get_pos(&pos
)) == 1)
2980 if (c
== -1 || (*mb_char2len
)(c
) <= 1
2981 || mb_get_class(ml_get_pos(&tpos
)) != 1)
2985 if (gchar_pos(&pos
) == NUL
)
2990 if ((*func
)(&pos
) == -1)
2999 /* skip white space */
3000 while (!noskip
&& ((c
= gchar_pos(&pos
)) == ' ' || c
== '\t'))
3001 if (incl(&pos
) == -1)
3006 curwin
->w_cursor
= pos
;
3011 * Find the next paragraph or section in direction 'dir'.
3012 * Paragraphs are currently supposed to be separated by empty lines.
3013 * If 'what' is NUL we go to the next paragraph.
3014 * If 'what' is '{' or '}' we go to the next section.
3015 * If 'both' is TRUE also stop at '}'.
3016 * Return TRUE if the next paragraph or section was found.
3019 findpar(pincl
, dir
, count
, what
, both
)
3020 int *pincl
; /* Return: TRUE if last char is to be included */
3027 int did_skip
; /* TRUE after separating lines have been skipped */
3028 int first
; /* TRUE on first line */
3029 int posix
= (vim_strchr(p_cpo
, CPO_PARA
) != NULL
);
3031 linenr_T fold_first
; /* first line of a closed fold */
3032 linenr_T fold_last
; /* last line of a closed fold */
3033 int fold_skipped
; /* TRUE if a closed fold was skipped this
3037 curr
= curwin
->w_cursor
.lnum
;
3042 for (first
= TRUE
; ; first
= FALSE
)
3044 if (*ml_get(curr
) != NUL
)
3048 /* skip folded lines */
3049 fold_skipped
= FALSE
;
3050 if (first
&& hasFolding(curr
, &fold_first
, &fold_last
))
3052 curr
= ((dir
> 0) ? fold_last
: fold_first
) + dir
;
3053 fold_skipped
= TRUE
;
3057 /* POSIX has it's own ideas of what a paragraph boundary is and it
3058 * doesn't match historical Vi: It also stops at a "{" in the
3059 * first column and at an empty line. */
3060 if (!first
&& did_skip
&& (startPS(curr
, what
, both
)
3061 || (posix
&& what
== NUL
&& *ml_get(curr
) == '{')))
3068 if ((curr
+= dir
) < 1 || curr
> curbuf
->b_ml
.ml_line_count
)
3078 if (both
&& *ml_get(curr
) == '}') /* include line with '}' */
3080 curwin
->w_cursor
.lnum
= curr
;
3081 if (curr
== curbuf
->b_ml
.ml_line_count
&& what
!= '}')
3083 if ((curwin
->w_cursor
.col
= (colnr_T
)STRLEN(ml_get(curr
))) != 0)
3085 --curwin
->w_cursor
.col
;
3090 curwin
->w_cursor
.col
= 0;
3095 * check if the string 's' is a nroff macro that is in option 'opt'
3104 for (macro
= opt
; macro
[0]; ++macro
)
3106 /* Accept two characters in the option being equal to two characters
3107 * in the line. A space in the option matches with a space in the
3108 * line or the line having ended. */
3109 if ( (macro
[0] == s
[0]
3111 && (s
[0] == NUL
|| s
[0] == ' ')))
3112 && (macro
[1] == s
[1]
3113 || ((macro
[1] == NUL
|| macro
[1] == ' ')
3114 && (s
[0] == NUL
|| s
[1] == NUL
|| s
[1] == ' '))))
3117 if (macro
[0] == NUL
)
3120 return (macro
[0] != NUL
);
3124 * startPS: return TRUE if line 'lnum' is the start of a section or paragraph.
3125 * If 'para' is '{' or '}' only check for sections.
3126 * If 'both' is TRUE also stop at '}'
3129 startPS(lnum
, para
, both
)
3137 if (*s
== para
|| *s
== '\f' || (both
&& *s
== '}'))
3139 if (*s
== '.' && (inmacro(p_sections
, s
+ 1) ||
3140 (!para
&& inmacro(p_para
, s
+ 1))))
3146 * The following routines do the word searches performed by the 'w', 'W',
3147 * 'b', 'B', 'e', and 'E' commands.
3151 * To perform these searches, characters are placed into one of three
3152 * classes, and transitions between classes determine word boundaries.
3158 * 2 or higher - keyword characters (letters, digits and underscore)
3161 static int cls_bigword
; /* TRUE for "W", "B" or "E" */
3164 * cls() - returns the class of character at curwin->w_cursor
3166 * If a 'W', 'B', or 'E' motion is being done (cls_bigword == TRUE), chars
3167 * from class 2 and higher are reported as class 1 since only white space
3168 * boundaries are of interest.
3176 #ifdef FEAT_FKMAP /* when 'akm' (Farsi mode), take care of Farsi blank */
3177 if (p_altkeymap
&& c
== F_BLANK
)
3180 if (c
== ' ' || c
== '\t' || c
== NUL
)
3183 if (enc_dbcs
!= 0 && c
> 0xFF)
3185 /* If cls_bigword, report multi-byte chars as class 1. */
3186 if (enc_dbcs
== DBCS_KOR
&& cls_bigword
)
3189 /* process code leading/trailing bytes */
3190 return dbcs_class(((unsigned)c
>> 8), (c
& 0xFF));
3195 if (c
!= 0 && cls_bigword
)
3201 /* If cls_bigword is TRUE, report all non-blanks as class 1. */
3212 * fwd_word(count, type, eol) - move forward one word
3214 * Returns FAIL if the cursor was already at the end of the file.
3215 * If eol is TRUE, last word stops at end of line (for operators).
3218 fwd_word(count
, bigword
, eol
)
3220 int bigword
; /* "W", "E" or "B" */
3223 int sclass
; /* starting class */
3227 #ifdef FEAT_VIRTUALEDIT
3228 curwin
->w_cursor
.coladd
= 0;
3230 cls_bigword
= bigword
;
3231 while (--count
>= 0)
3234 /* When inside a range of folded lines, move to the last char of the
3236 if (hasFolding(curwin
->w_cursor
.lnum
, NULL
, &curwin
->w_cursor
.lnum
))
3237 coladvance((colnr_T
)MAXCOL
);
3242 * We always move at least one character, unless on the last
3243 * character in the buffer.
3245 last_line
= (curwin
->w_cursor
.lnum
== curbuf
->b_ml
.ml_line_count
);
3247 if (i
== -1 || (i
>= 1 && last_line
)) /* started at last char in file */
3249 if (i
>= 1 && eol
&& count
== 0) /* started at last char in line */
3253 * Go one char past end of current word (if any)
3256 while (cls() == sclass
)
3259 if (i
== -1 || (i
>= 1 && eol
&& count
== 0))
3264 * go to next non-white
3269 * We'll stop if we land on a blank line
3271 if (curwin
->w_cursor
.col
== 0 && *ml_get_curline() == NUL
)
3275 if (i
== -1 || (i
>= 1 && eol
&& count
== 0))
3283 * bck_word() - move backward 'count' words
3285 * If stop is TRUE and we are already on the start of a word, move one less.
3287 * Returns FAIL if top of the file was reached.
3290 bck_word(count
, bigword
, stop
)
3295 int sclass
; /* starting class */
3297 #ifdef FEAT_VIRTUALEDIT
3298 curwin
->w_cursor
.coladd
= 0;
3300 cls_bigword
= bigword
;
3301 while (--count
>= 0)
3304 /* When inside a range of folded lines, move to the first char of the
3306 if (hasFolding(curwin
->w_cursor
.lnum
, &curwin
->w_cursor
.lnum
, NULL
))
3307 curwin
->w_cursor
.col
= 0;
3310 if (dec_cursor() == -1) /* started at start of file */
3313 if (!stop
|| sclass
== cls() || sclass
== 0)
3316 * Skip white space before the word.
3317 * Stop on an empty line.
3321 if (curwin
->w_cursor
.col
== 0
3322 && lineempty(curwin
->w_cursor
.lnum
))
3324 if (dec_cursor() == -1) /* hit start of file, stop here */
3329 * Move backward to start of this word.
3331 if (skip_chars(cls(), BACKWARD
))
3335 inc_cursor(); /* overshot - forward one */
3343 * end_word() - move to the end of the word
3345 * There is an apparent bug in the 'e' motion of the real vi. At least on the
3346 * System V Release 3 version for the 80386. Unlike 'b' and 'w', the 'e'
3347 * motion crosses blank lines. When the real vi crosses a blank line in an
3348 * 'e' motion, the cursor is placed on the FIRST character of the next
3349 * non-blank line. The 'E' command, however, works correctly. Since this
3350 * appears to be a bug, I have not duplicated it here.
3352 * Returns FAIL if end of the file was reached.
3354 * If stop is TRUE and we are already on the end of a word, move one less.
3355 * If empty is TRUE stop on an empty line.
3358 end_word(count
, bigword
, stop
, empty
)
3364 int sclass
; /* starting class */
3366 #ifdef FEAT_VIRTUALEDIT
3367 curwin
->w_cursor
.coladd
= 0;
3369 cls_bigword
= bigword
;
3370 while (--count
>= 0)
3373 /* When inside a range of folded lines, move to the last char of the
3375 if (hasFolding(curwin
->w_cursor
.lnum
, NULL
, &curwin
->w_cursor
.lnum
))
3376 coladvance((colnr_T
)MAXCOL
);
3379 if (inc_cursor() == -1)
3383 * If we're in the middle of a word, we just have to move to the end
3386 if (cls() == sclass
&& sclass
!= 0)
3389 * Move forward to end of the current word
3391 if (skip_chars(sclass
, FORWARD
))
3394 else if (!stop
|| sclass
== 0)
3397 * We were at the end of a word. Go to the end of the next word.
3398 * First skip white space, if 'empty' is TRUE, stop at empty line.
3402 if (empty
&& curwin
->w_cursor
.col
== 0
3403 && lineempty(curwin
->w_cursor
.lnum
))
3405 if (inc_cursor() == -1) /* hit end of file, stop here */
3410 * Move forward to the end of this word.
3412 if (skip_chars(cls(), FORWARD
))
3415 dec_cursor(); /* overshot - one char backward */
3417 stop
= FALSE
; /* we move only one word less */
3423 * Move back to the end of the word.
3425 * Returns FAIL if start of the file was reached.
3428 bckend_word(count
, bigword
, eol
)
3430 int bigword
; /* TRUE for "B" */
3431 int eol
; /* TRUE: stop at end of line. */
3433 int sclass
; /* starting class */
3436 #ifdef FEAT_VIRTUALEDIT
3437 curwin
->w_cursor
.coladd
= 0;
3439 cls_bigword
= bigword
;
3440 while (--count
>= 0)
3443 if ((i
= dec_cursor()) == -1)
3449 * Move backward to before the start of this word.
3453 while (cls() == sclass
)
3454 if ((i
= dec_cursor()) == -1 || (eol
&& i
== 1))
3459 * Move backward to end of the previous word
3463 if (curwin
->w_cursor
.col
== 0 && lineempty(curwin
->w_cursor
.lnum
))
3465 if ((i
= dec_cursor()) == -1 || (eol
&& i
== 1))
3473 * Skip a row of characters of the same class.
3474 * Return TRUE when end-of-file reached, FALSE otherwise.
3477 skip_chars(cclass
, dir
)
3481 while (cls() == cclass
)
3482 if ((dir
== FORWARD
? inc_cursor() : dec_cursor()) == -1)
3489 * Go back to the start of the word or the start of white space
3494 int sclass
; /* starting class */
3499 if (curwin
->w_cursor
.col
== 0) /* stop at start of line */
3502 if (cls() != sclass
) /* stop at start of word */
3511 find_first_blank(posp
)
3516 while (decl(posp
) != -1)
3518 c
= gchar_pos(posp
);
3519 if (!vim_iswhite(c
))
3528 * Skip count/2 sentences and count/2 separating white spaces.
3531 findsent_forward(count
, at_start_sent
)
3533 int at_start_sent
; /* cursor is at start of sentence */
3537 findsent(FORWARD
, 1L);
3539 find_first_blank(&curwin
->w_cursor
);
3540 if (count
== 0 || at_start_sent
)
3541 decl(&curwin
->w_cursor
);
3542 at_start_sent
= !at_start_sent
;
3547 * Find word under cursor, cursor at end.
3548 * Used while an operator is pending, and in Visual mode.
3551 current_word(oap
, count
, include
, bigword
)
3554 int include
; /* TRUE: include word and white space */
3555 int bigword
; /* FALSE == word, TRUE == WORD */
3559 int inclusive
= TRUE
;
3560 int include_white
= FALSE
;
3562 cls_bigword
= bigword
;
3563 clearpos(&start_pos
);
3566 /* Correct cursor when 'selection' is exclusive */
3567 if (VIsual_active
&& *p_sel
== 'e' && lt(VIsual
, curwin
->w_cursor
))
3571 * When Visual mode is not active, or when the VIsual area is only one
3572 * character, select the word and/or white space under the cursor.
3574 if (!VIsual_active
|| equalpos(curwin
->w_cursor
, VIsual
))
3578 * Go to start of current word or white space.
3581 start_pos
= curwin
->w_cursor
;
3584 * If the start is on white space, and white space should be included
3585 * (" word"), or start is not on white space, and white space should
3586 * not be included ("word"), find end of word.
3588 if ((cls() == 0) == include
)
3590 if (end_word(1L, bigword
, TRUE
, TRUE
) == FAIL
)
3596 * If the start is not on white space, and white space should be
3597 * included ("word "), or start is on white space and white
3598 * space should not be included (" "), find start of word.
3599 * If we end up in the first column of the next line (single char
3600 * word) back up to end of the line.
3602 fwd_word(1L, bigword
, TRUE
);
3603 if (curwin
->w_cursor
.col
== 0)
3604 decl(&curwin
->w_cursor
);
3609 include_white
= TRUE
;
3615 /* should do something when inclusive == FALSE ! */
3617 redraw_curbuf_later(INVERTED
); /* update the inversion */
3622 oap
->start
= start_pos
;
3623 oap
->motion_type
= MCHAR
;
3629 * When count is still > 0, extend with more objects.
3635 if (VIsual_active
&& lt(curwin
->w_cursor
, VIsual
))
3638 * In Visual mode, with cursor at start: move cursor back.
3640 if (decl(&curwin
->w_cursor
) == -1)
3642 if (include
!= (cls() != 0))
3644 if (bck_word(1L, bigword
, TRUE
) == FAIL
)
3649 if (bckend_word(1L, bigword
, TRUE
) == FAIL
)
3651 (void)incl(&curwin
->w_cursor
);
3658 * Move cursor forward one word and/or white area.
3660 if (incl(&curwin
->w_cursor
) == -1)
3662 if (include
!= (cls() == 0))
3664 if (fwd_word(1L, bigword
, TRUE
) == FAIL
&& count
> 1)
3667 * If end is just past a new-line, we don't want to include
3668 * the first character on the line.
3669 * Put cursor on last char of white.
3671 if (oneleft() == FAIL
)
3676 if (end_word(1L, bigword
, TRUE
, TRUE
) == FAIL
)
3683 if (include_white
&& (cls() != 0
3684 || (curwin
->w_cursor
.col
== 0 && !inclusive
)))
3687 * If we don't include white space at the end, move the start
3688 * to include some white space there. This makes "daw" work
3689 * better on the last word in a sentence (and "2daw" on last-but-one
3690 * word). Also when "2daw" deletes "word." at the end of the line
3691 * (cursor is at start of next line).
3692 * But don't delete white space at start of line (indent).
3694 pos
= curwin
->w_cursor
; /* save cursor position */
3695 curwin
->w_cursor
= start_pos
;
3696 if (oneleft() == OK
)
3699 if (cls() == 0 && curwin
->w_cursor
.col
> 0)
3703 VIsual
= curwin
->w_cursor
;
3706 oap
->start
= curwin
->w_cursor
;
3709 curwin
->w_cursor
= pos
; /* put cursor back at end */
3715 if (*p_sel
== 'e' && inclusive
&& ltoreq(VIsual
, curwin
->w_cursor
))
3717 if (VIsual_mode
== 'V')
3720 redraw_cmdline
= TRUE
; /* show mode later */
3725 oap
->inclusive
= inclusive
;
3731 * Find sentence(s) under the cursor, cursor at end.
3732 * When Visual active, extend it by one or more sentences.
3735 current_sent(oap
, count
, include
)
3747 start_pos
= curwin
->w_cursor
;
3749 findsent(FORWARD
, 1L); /* Find start of next sentence. */
3753 * When visual area is bigger than one character: Extend it.
3755 if (VIsual_active
&& !equalpos(start_pos
, VIsual
))
3758 if (lt(start_pos
, VIsual
))
3761 * Cursor at start of Visual area.
3762 * Find out where we are:
3763 * - in the white space before a sentence
3764 * - in a sentence or just after it
3765 * - at the start of a sentence
3767 at_start_sent
= TRUE
;
3769 while (lt(pos
, curwin
->w_cursor
))
3771 c
= gchar_pos(&pos
);
3772 if (!vim_iswhite(c
))
3774 at_start_sent
= FALSE
;
3781 findsent(BACKWARD
, 1L);
3782 if (equalpos(curwin
->w_cursor
, start_pos
))
3783 at_start_sent
= TRUE
; /* exactly at start of sentence */
3785 /* inside a sentence, go to its end (start of next) */
3786 findsent(FORWARD
, 1L);
3788 if (include
) /* "as" gets twice as much as "is" */
3793 find_first_blank(&curwin
->w_cursor
);
3795 if (!at_start_sent
|| (!include
&& !vim_iswhite(c
)))
3796 findsent(BACKWARD
, 1L);
3797 at_start_sent
= !at_start_sent
;
3803 * Cursor at end of Visual area.
3804 * Find out where we are:
3805 * - just before a sentence
3806 * - just before or in the white space before a sentence
3810 at_start_sent
= TRUE
;
3811 if (!equalpos(pos
, curwin
->w_cursor
)) /* not just before a sentence */
3813 at_start_sent
= FALSE
;
3814 while (lt(pos
, curwin
->w_cursor
))
3816 c
= gchar_pos(&pos
);
3817 if (!vim_iswhite(c
))
3819 at_start_sent
= TRUE
;
3824 if (at_start_sent
) /* in the sentence */
3825 findsent(BACKWARD
, 1L);
3826 else /* in/before white before a sentence */
3827 curwin
->w_cursor
= start_pos
;
3830 if (include
) /* "as" gets twice as much as "is" */
3832 findsent_forward(count
, at_start_sent
);
3834 ++curwin
->w_cursor
.col
;
3841 * If cursor started on blank, check if it is just before the start of the
3844 while (c
= gchar_pos(&pos
), vim_iswhite(c
)) /* vim_iswhite() is a macro */
3846 if (equalpos(pos
, curwin
->w_cursor
))
3849 find_first_blank(&start_pos
); /* go back to first blank */
3853 start_blank
= FALSE
;
3854 findsent(BACKWARD
, 1L);
3855 start_pos
= curwin
->w_cursor
;
3866 findsent_forward(ncount
, TRUE
);
3868 decl(&curwin
->w_cursor
);
3873 * If the blank in front of the sentence is included, exclude the
3874 * blanks at the end of the sentence, go back to the first blank.
3875 * If there are no trailing blanks, try to include leading blanks.
3879 find_first_blank(&curwin
->w_cursor
);
3880 c
= gchar_pos(&curwin
->w_cursor
); /* vim_iswhite() is a macro */
3882 decl(&curwin
->w_cursor
);
3884 else if (c
= gchar_cursor(), !vim_iswhite(c
))
3885 find_first_blank(&start_pos
);
3891 /* avoid getting stuck with "is" on a single space before a sent. */
3892 if (equalpos(start_pos
, curwin
->w_cursor
))
3895 ++curwin
->w_cursor
.col
;
3898 redraw_curbuf_later(INVERTED
); /* update the inversion */
3903 /* include a newline after the sentence, if there is one */
3904 if (incl(&curwin
->w_cursor
) == -1)
3905 oap
->inclusive
= TRUE
;
3907 oap
->inclusive
= FALSE
;
3908 oap
->start
= start_pos
;
3909 oap
->motion_type
= MCHAR
;
3915 * Find block under the cursor, cursor at end.
3916 * "what" and "other" are two matching parenthesis/paren/etc.
3919 current_block(oap
, count
, include
, what
, other
)
3922 int include
; /* TRUE == include white space */
3923 int what
; /* '(', '{', etc. */
3924 int other
; /* ')', '}', etc. */
3930 pos_T old_start
, old_end
;
3932 int sol
= FALSE
; /* '{' at start of line */
3934 old_pos
= curwin
->w_cursor
;
3935 old_end
= curwin
->w_cursor
; /* remember where we started */
3936 old_start
= old_end
;
3939 * If we start on '(', '{', ')', '}', etc., use the whole block inclusive.
3942 if (!VIsual_active
|| equalpos(VIsual
, curwin
->w_cursor
))
3946 if (what
== '{') /* ignore indent */
3948 if (inc_cursor() != 0)
3950 if (gchar_cursor() == what
)
3951 /* cursor on '(' or '{', move cursor just after it */
3952 ++curwin
->w_cursor
.col
;
3955 else if (lt(VIsual
, curwin
->w_cursor
))
3958 curwin
->w_cursor
= VIsual
; /* cursor at low end of Visual */
3965 * Search backwards for unclosed '(', '{', etc..
3966 * Put this position in start_pos.
3967 * Ignore quotes here.
3970 p_cpo
= (char_u
*)"%";
3973 if ((pos
= findmatch(NULL
, what
)) == NULL
)
3975 curwin
->w_cursor
= *pos
;
3976 start_pos
= *pos
; /* the findmatch for end_pos will overwrite *pos */
3981 * Search for matching ')', '}', etc.
3982 * Put this position in curwin->w_cursor.
3984 if (pos
== NULL
|| (end_pos
= findmatch(NULL
, other
)) == NULL
)
3986 curwin
->w_cursor
= old_pos
;
3989 curwin
->w_cursor
= *end_pos
;
3992 * Try to exclude the '(', '{', ')', '}', etc. when "include" is FALSE.
3993 * If the ending '}' is only preceded by indent, skip that indent.
3994 * But only if the resulting area is not smaller than what we started with.
3999 sol
= (curwin
->w_cursor
.col
== 0);
4000 decl(&curwin
->w_cursor
);
4005 if (decl(&curwin
->w_cursor
) != 0)
4010 * In Visual mode, when the resulting area is not bigger than what we
4011 * started with, extend it to the next block, and then exclude again.
4013 if (!lt(start_pos
, old_start
) && !lt(old_end
, curwin
->w_cursor
)
4016 curwin
->w_cursor
= old_start
;
4017 decl(&curwin
->w_cursor
);
4018 if ((pos
= findmatch(NULL
, what
)) == NULL
)
4020 curwin
->w_cursor
= old_pos
;
4024 curwin
->w_cursor
= *pos
;
4025 if ((end_pos
= findmatch(NULL
, other
)) == NULL
)
4027 curwin
->w_cursor
= old_pos
;
4030 curwin
->w_cursor
= *end_pos
;
4041 ++curwin
->w_cursor
.col
;
4042 if (sol
&& gchar_cursor() != NUL
)
4043 inc(&curwin
->w_cursor
); /* include the line break */
4046 redraw_curbuf_later(INVERTED
); /* update the inversion */
4052 oap
->start
= start_pos
;
4053 oap
->motion_type
= MCHAR
;
4054 oap
->inclusive
= FALSE
;
4056 incl(&curwin
->w_cursor
);
4057 else if (ltoreq(start_pos
, curwin
->w_cursor
))
4058 /* Include the character under the cursor. */
4059 oap
->inclusive
= TRUE
;
4061 /* End is before the start (no text in between <>, [], etc.): don't
4062 * operate on any text. */
4063 curwin
->w_cursor
= start_pos
;
4069 static int in_html_tag
__ARGS((int));
4072 * Return TRUE if the cursor is on a "<aaa>" tag. Ignore "<aaa/>".
4073 * When "end_tag" is TRUE return TRUE if the cursor is on "</aaa>".
4076 in_html_tag(end_tag
)
4079 char_u
*line
= ml_get_curline();
4090 /* We search forward until the cursor, because searching backwards is
4091 * very slow for DBCS encodings. */
4092 for (p
= line
; p
< line
+ curwin
->w_cursor
.col
; mb_ptr_adv(p
))
4093 if (*p
== '>' || *p
== '<')
4098 if (*p
!= '<') /* check for '<' under cursor */
4108 for (p
= line
+ curwin
->w_cursor
.col
; p
> line
; )
4110 if (*p
== '<') /* find '<' under/before cursor */
4112 mb_ptr_back(line
, p
);
4113 if (*p
== '>') /* find '>' before cursor */
4120 pos
.lnum
= curwin
->w_cursor
.lnum
;
4121 pos
.col
= (colnr_T
)(p
- line
);
4125 /* check that there is a '/' after the '<' */
4128 /* check that there is no '/' after the '<' */
4132 /* check that the matching '>' is not preceded by '/' */
4137 c
= *ml_get_pos(&pos
);
4146 * Find tag block under the cursor, cursor at end.
4149 current_tagblock(oap
, count_arg
, include
)
4152 int include
; /* TRUE == include white space */
4154 long count
= count_arg
;
4159 pos_T old_start
, old_end
;
4160 char_u
*spat
, *epat
;
4165 int do_include
= include
;
4166 int save_p_ws
= p_ws
;
4171 old_pos
= curwin
->w_cursor
;
4172 old_end
= curwin
->w_cursor
; /* remember where we started */
4173 old_start
= old_end
;
4175 if (!VIsual_active
|| *p_sel
== 'e')
4177 decl(&old_end
); /* old_end is inclusive */
4180 * If we start on "<aaa>" select that block.
4183 if (!VIsual_active
|| equalpos(VIsual
, curwin
->w_cursor
))
4190 if (inc_cursor() != 0)
4193 if (in_html_tag(FALSE
))
4195 /* cursor on start tag, move to its '>' */
4196 while (*ml_get_cursor() != '>')
4197 if (inc_cursor() < 0)
4200 else if (in_html_tag(TRUE
))
4202 /* cursor on end tag, move to just before it */
4203 while (*ml_get_cursor() != '<')
4204 if (dec_cursor() < 0)
4207 old_end
= curwin
->w_cursor
;
4211 else if (lt(VIsual
, curwin
->w_cursor
))
4214 curwin
->w_cursor
= VIsual
; /* cursor at low end of Visual */
4222 * Search backwards for unclosed "<aaa>".
4223 * Put this position in start_pos.
4225 for (n
= 0; n
< count
; ++n
)
4227 if (do_searchpair((char_u
*)"<[^ \t>/!]\\+\\%(\\_s\\_[^>]\\{-}[^/]>\\|$\\|\\_s\\=>\\)",
4229 (char_u
*)"</[^>]*>", BACKWARD
, (char_u
*)"", 0,
4230 NULL
, (linenr_T
)0, 0L) <= 0)
4232 curwin
->w_cursor
= old_pos
;
4236 start_pos
= curwin
->w_cursor
;
4239 * Search for matching "</aaa>". First isolate the "aaa".
4242 p
= ml_get_cursor();
4243 for (cp
= p
; *cp
!= NUL
&& *cp
!= '>' && !vim_iswhite(*cp
); mb_ptr_adv(cp
))
4245 len
= (int)(cp
- p
);
4248 curwin
->w_cursor
= old_pos
;
4251 spat
= alloc(len
+ 29);
4252 epat
= alloc(len
+ 9);
4253 if (spat
== NULL
|| epat
== NULL
)
4257 curwin
->w_cursor
= old_pos
;
4260 sprintf((char *)spat
, "<%.*s\\%%(\\_[^>]\\{-}[^/]>\\|>\\)\\c", len
, p
);
4261 sprintf((char *)epat
, "</%.*s>\\c", len
, p
);
4263 r
= do_searchpair(spat
, (char_u
*)"", epat
, FORWARD
, (char_u
*)"",
4264 0, NULL
, (linenr_T
)0, 0L);
4269 if (r
< 1 || lt(curwin
->w_cursor
, old_end
))
4271 /* Can't find other end or it's before the previous end. Could be a
4272 * HTML tag that doesn't have a matching end. Search backwards for
4273 * another starting tag. */
4275 curwin
->w_cursor
= start_pos
;
4279 if (do_include
|| r
< 1)
4281 /* Include up to the '>'. */
4282 while (*ml_get_cursor() != '>')
4283 if (inc_cursor() < 0)
4288 /* Exclude the '<' of the end tag. */
4289 if (*ml_get_cursor() == '<')
4292 end_pos
= curwin
->w_cursor
;
4296 /* Exclude the start tag. */
4297 curwin
->w_cursor
= start_pos
;
4298 while (inc_cursor() >= 0)
4299 if (*ml_get_cursor() == '>')
4302 start_pos
= curwin
->w_cursor
;
4305 curwin
->w_cursor
= end_pos
;
4307 /* If we now have the same text as before reset "do_include" and try
4309 if (equalpos(start_pos
, old_start
) && equalpos(end_pos
, old_end
))
4312 curwin
->w_cursor
= old_start
;
4321 /* If the end is before the start there is no text between tags, select
4322 * the char under the cursor. */
4323 if (lt(end_pos
, start_pos
))
4324 curwin
->w_cursor
= start_pos
;
4325 else if (*p_sel
== 'e')
4326 ++curwin
->w_cursor
.col
;
4329 redraw_curbuf_later(INVERTED
); /* update the inversion */
4335 oap
->start
= start_pos
;
4336 oap
->motion_type
= MCHAR
;
4337 if (lt(end_pos
, start_pos
))
4339 /* End is before the start: there is no text between tags; operate
4340 * on an empty area. */
4341 curwin
->w_cursor
= start_pos
;
4342 oap
->inclusive
= FALSE
;
4345 oap
->inclusive
= TRUE
;
4355 current_par(oap
, count
, include
, type
)
4358 int include
; /* TRUE == include white space */
4359 int type
; /* 'p' for paragraph, 'S' for section */
4361 linenr_T start_lnum
;
4366 int prev_start_is_white
;
4368 int do_white
= FALSE
;
4372 if (type
== 'S') /* not implemented yet */
4375 start_lnum
= curwin
->w_cursor
.lnum
;
4379 * When visual area is more than one line: extend it.
4381 if (VIsual_active
&& start_lnum
!= VIsual
.lnum
)
4384 if (start_lnum
< VIsual
.lnum
)
4388 for (i
= count
; --i
>= 0; )
4391 (dir
== BACKWARD
? 1 : curbuf
->b_ml
.ml_line_count
))
4397 prev_start_is_white
= -1;
4398 for (t
= 0; t
< 2; ++t
)
4401 start_is_white
= linewhite(start_lnum
);
4402 if (prev_start_is_white
== start_is_white
)
4409 if (start_lnum
== (dir
== BACKWARD
4410 ? 1 : curbuf
->b_ml
.ml_line_count
))
4412 if (start_is_white
!= linewhite(start_lnum
+ dir
)
4414 && startPS(start_lnum
+ (dir
> 0
4421 if (start_lnum
== (dir
== BACKWARD
4422 ? 1 : curbuf
->b_ml
.ml_line_count
))
4424 prev_start_is_white
= start_is_white
;
4427 curwin
->w_cursor
.lnum
= start_lnum
;
4428 curwin
->w_cursor
.col
= 0;
4434 * First move back to the start_lnum of the paragraph or white lines
4436 white_in_front
= linewhite(start_lnum
);
4437 while (start_lnum
> 1)
4439 if (white_in_front
) /* stop at first white line */
4441 if (!linewhite(start_lnum
- 1))
4444 else /* stop at first non-white line of start of paragraph */
4446 if (linewhite(start_lnum
- 1) || startPS(start_lnum
, 0, 0))
4453 * Move past the end of any white lines.
4455 end_lnum
= start_lnum
;
4456 while (end_lnum
<= curbuf
->b_ml
.ml_line_count
&& linewhite(end_lnum
))
4461 if (!include
&& white_in_front
)
4465 if (end_lnum
== curbuf
->b_ml
.ml_line_count
)
4469 do_white
= linewhite(end_lnum
+ 1);
4471 if (include
|| !do_white
)
4475 * skip to end of paragraph
4477 while (end_lnum
< curbuf
->b_ml
.ml_line_count
4478 && !linewhite(end_lnum
+ 1)
4479 && !startPS(end_lnum
+ 1, 0, 0))
4483 if (i
== 0 && white_in_front
&& include
)
4487 * skip to end of white lines after paragraph
4489 if (include
|| do_white
)
4490 while (end_lnum
< curbuf
->b_ml
.ml_line_count
4491 && linewhite(end_lnum
+ 1))
4496 * If there are no empty lines at the end, try to find some empty lines at
4497 * the start (unless that has been done already).
4499 if (!white_in_front
&& !linewhite(end_lnum
) && include
)
4500 while (start_lnum
> 1 && linewhite(start_lnum
- 1))
4506 /* Problem: when doing "Vipipip" nothing happens in a single white
4507 * line, we get stuck there. Trap this here. */
4508 if (VIsual_mode
== 'V' && start_lnum
== curwin
->w_cursor
.lnum
)
4510 VIsual
.lnum
= start_lnum
;
4512 redraw_curbuf_later(INVERTED
); /* update the inversion */
4518 oap
->start
.lnum
= start_lnum
;
4520 oap
->motion_type
= MLINE
;
4522 curwin
->w_cursor
.lnum
= end_lnum
;
4523 curwin
->w_cursor
.col
= 0;
4528 static int find_next_quote
__ARGS((char_u
*top_ptr
, int col
, int quotechar
, char_u
*escape
));
4529 static int find_prev_quote
__ARGS((char_u
*line
, int col_start
, int quotechar
, char_u
*escape
));
4532 * Search quote char from string line[col].
4533 * Quote character escaped by one of the characters in "escape" is not counted
4535 * Returns column number of "quotechar" or -1 when not found.
4538 find_next_quote(line
, col
, quotechar
, escape
)
4542 char_u
*escape
; /* escape characters, can be NULL */
4551 else if (escape
!= NULL
&& vim_strchr(escape
, c
))
4553 else if (c
== quotechar
)
4557 col
+= (*mb_ptr2len
)(line
+ col
);
4566 * Search backwards in "line" from column "col_start" to find "quotechar".
4567 * Quote character escaped by one of the characters in "escape" is not counted
4569 * Return the found column or zero.
4572 find_prev_quote(line
, col_start
, quotechar
, escape
)
4576 char_u
*escape
; /* escape characters, can be NULL */
4580 while (col_start
> 0)
4584 col_start
-= (*mb_head_off
)(line
, line
+ col_start
);
4588 while (col_start
- n
> 0 && vim_strchr(escape
,
4589 line
[col_start
- n
- 1]) != NULL
)
4592 col_start
-= n
; /* uneven number of escape chars, skip it */
4593 else if (line
[col_start
] == quotechar
)
4600 * Find quote under the cursor, cursor at end.
4601 * Returns TRUE if found, else FALSE.
4604 current_quote(oap
, count
, include
, quotechar
)
4607 int include
; /* TRUE == include quote char */
4608 int quotechar
; /* Quote character */
4610 char_u
*line
= ml_get_curline();
4612 int col_start
= curwin
->w_cursor
.col
;
4613 int inclusive
= FALSE
;
4615 int vis_empty
= TRUE
; /* Visual selection <= 1 char */
4616 int vis_bef_curs
= FALSE
; /* Visual starts before cursor */
4617 int inside_quotes
= FALSE
; /* Looks like "i'" done before */
4618 int selected_quote
= FALSE
; /* Has quote inside selection */
4621 /* Correct cursor when 'selection' is exclusive */
4624 vis_bef_curs
= lt(VIsual
, curwin
->w_cursor
);
4625 if (*p_sel
== 'e' && vis_bef_curs
)
4627 vis_empty
= equalpos(VIsual
, curwin
->w_cursor
);
4632 /* Check if the existing selection exactly spans the text inside
4636 inside_quotes
= VIsual
.col
> 0
4637 && line
[VIsual
.col
- 1] == quotechar
4638 && line
[curwin
->w_cursor
.col
] != NUL
4639 && line
[curwin
->w_cursor
.col
+ 1] == quotechar
;
4641 col_end
= curwin
->w_cursor
.col
;
4645 inside_quotes
= curwin
->w_cursor
.col
> 0
4646 && line
[curwin
->w_cursor
.col
- 1] == quotechar
4647 && line
[VIsual
.col
] != NUL
4648 && line
[VIsual
.col
+ 1] == quotechar
;
4649 i
= curwin
->w_cursor
.col
;
4650 col_end
= VIsual
.col
;
4653 /* Find out if we have a quote in the selection. */
4654 while (i
<= col_end
)
4655 if (line
[i
++] == quotechar
)
4657 selected_quote
= TRUE
;
4662 if (!vis_empty
&& line
[col_start
] == quotechar
)
4664 /* Already selecting something and on a quote character. Find the
4665 * next quoted string. */
4668 /* Assume we are on a closing quote: move to after the next
4670 col_start
= find_next_quote(line
, col_start
+ 1, quotechar
, NULL
);
4673 col_end
= find_next_quote(line
, col_start
+ 1, quotechar
,
4677 /* We were on a starting quote perhaps? */
4678 col_end
= col_start
;
4679 col_start
= curwin
->w_cursor
.col
;
4684 col_end
= find_prev_quote(line
, col_start
, quotechar
, NULL
);
4685 if (line
[col_end
] != quotechar
)
4687 col_start
= find_prev_quote(line
, col_end
, quotechar
,
4689 if (line
[col_start
] != quotechar
)
4691 /* We were on an ending quote perhaps? */
4692 col_start
= col_end
;
4693 col_end
= curwin
->w_cursor
.col
;
4700 if (line
[col_start
] == quotechar
4706 int first_col
= col_start
;
4712 first_col
= find_next_quote(line
, col_start
, quotechar
, NULL
);
4714 first_col
= find_prev_quote(line
, col_start
, quotechar
, NULL
);
4717 /* The cursor is on a quote, we don't know if it's the opening or
4718 * closing quote. Search from the start of the line to find out.
4719 * Also do this when there is a Visual area, a' may leave the cursor
4720 * in between two strings. */
4724 /* Find open quote character. */
4725 col_start
= find_next_quote(line
, col_start
, quotechar
, NULL
);
4726 if (col_start
< 0 || col_start
> first_col
)
4728 /* Find close quote character. */
4729 col_end
= find_next_quote(line
, col_start
+ 1, quotechar
,
4733 /* If is cursor between start and end quote character, it is
4734 * target text object. */
4735 if (col_start
<= first_col
&& first_col
<= col_end
)
4737 col_start
= col_end
+ 1;
4742 /* Search backward for a starting quote. */
4743 col_start
= find_prev_quote(line
, col_start
, quotechar
, curbuf
->b_p_qe
);
4744 if (line
[col_start
] != quotechar
)
4746 /* No quote before the cursor, look after the cursor. */
4747 col_start
= find_next_quote(line
, col_start
, quotechar
, NULL
);
4752 /* Find close quote character. */
4753 col_end
= find_next_quote(line
, col_start
+ 1, quotechar
,
4759 /* When "include" is TRUE, include spaces after closing quote or before
4760 * the starting quote. */
4763 if (vim_iswhite(line
[col_end
+ 1]))
4764 while (vim_iswhite(line
[col_end
+ 1]))
4767 while (col_start
> 0 && vim_iswhite(line
[col_start
- 1]))
4771 /* Set start position. After vi" another i" must include the ".
4772 * For v2i" include the quotes. */
4773 if (!include
&& count
< 2
4775 && (vis_empty
|| !inside_quotes
)
4779 curwin
->w_cursor
.col
= col_start
;
4783 /* Set the start of the Visual area when the Visual area was empty, we
4784 * were just inside quotes or the Visual area didn't start at a quote
4785 * and didn't include a quote.
4791 || (line
[VIsual
.col
] != quotechar
4793 || line
[VIsual
.col
- 1] != quotechar
)))))
4795 VIsual
= curwin
->w_cursor
;
4796 redraw_curbuf_later(INVERTED
);
4802 oap
->start
= curwin
->w_cursor
;
4803 oap
->motion_type
= MCHAR
;
4806 /* Set end position. */
4807 curwin
->w_cursor
.col
= col_end
;
4808 if ((include
|| count
> 1
4810 /* After vi" another i" must include the ". */
4811 || (!vis_empty
&& inside_quotes
)
4813 ) && inc_cursor() == 2)
4818 if (vis_empty
|| vis_bef_curs
)
4820 /* decrement cursor when 'selection' is not exclusive */
4826 /* Cursor is at start of Visual area. Set the end of the Visual
4827 * area when it was just inside quotes or it didn't end at a
4831 && line
[VIsual
.col
] != quotechar
4832 && (line
[VIsual
.col
] == NUL
4833 || line
[VIsual
.col
+ 1] != quotechar
)))
4836 VIsual
= curwin
->w_cursor
;
4838 curwin
->w_cursor
.col
= col_start
;
4840 if (VIsual_mode
== 'V')
4843 redraw_cmdline
= TRUE
; /* show mode later */
4849 /* Set inclusive and other oap's flags. */
4850 oap
->inclusive
= inclusive
;
4856 #endif /* FEAT_TEXTOBJ */
4858 #if defined(FEAT_LISP) || defined(FEAT_CINDENT) || defined(FEAT_TEXTOBJ) \
4861 * return TRUE if line 'lnum' is empty or has white chars only.
4869 p
= skipwhite(ml_get(lnum
));
4874 #if defined(FEAT_FIND_ID) || defined(PROTO)
4876 * Find identifiers or defines in included files.
4877 * if p_ic && (compl_cont_status & CONT_SOL) then ptr must be in lowercase.
4880 find_pattern_in_path(ptr
, dir
, len
, whole
, skip_comments
,
4881 type
, count
, action
, start_lnum
, end_lnum
)
4882 char_u
*ptr
; /* pointer to search pattern */
4883 int dir UNUSED
; /* direction of expansion */
4884 int len
; /* length of search pattern */
4885 int whole
; /* match whole words only */
4886 int skip_comments
; /* don't match inside comments */
4887 int type
; /* Type of search; are we looking for a type?
4890 int action
; /* What to do when we find it */
4891 linenr_T start_lnum
; /* first line to start searching */
4892 linenr_T end_lnum
; /* last line for searching */
4894 SearchedFile
*files
; /* Stack of included files */
4895 SearchedFile
*bigger
; /* When we need more space */
4896 int max_path_depth
= 50;
4897 long match_count
= 1;
4901 char_u
*curr_fname
= curbuf
->b_fname
;
4902 char_u
*prev_fname
= NULL
;
4905 int depth_displayed
; /* For type==CHECK_PATH */
4907 int already_searched
;
4913 regmatch_T regmatch
;
4914 regmatch_T incl_regmatch
;
4915 regmatch_T def_regmatch
;
4916 int matched
= FALSE
;
4917 int did_show
= FALSE
;
4920 char_u
*already
= NULL
;
4921 char_u
*startp
= NULL
;
4922 char_u
*inc_opt
= NULL
;
4924 int previous_munging
= __riscosify_control
;
4926 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
4927 win_T
*curwin_save
= NULL
;
4930 regmatch
.regprog
= NULL
;
4931 incl_regmatch
.regprog
= NULL
;
4932 def_regmatch
.regprog
= NULL
;
4934 file_line
= alloc(LSIZE
);
4935 if (file_line
== NULL
)
4939 /* UnixLib knows best how to munge c file names - turn munging back on. */
4940 int __riscosify_control
= 0;
4943 if (type
!= CHECK_PATH
&& type
!= FIND_DEFINE
4944 #ifdef FEAT_INS_EXPAND
4945 /* when CONT_SOL is set compare "ptr" with the beginning of the line
4946 * is faster than quote_meta/regcomp/regexec "ptr" -- Acevedo */
4947 && !(compl_cont_status
& CONT_SOL
)
4951 pat
= alloc(len
+ 5);
4954 sprintf((char *)pat
, whole
? "\\<%.*s\\>" : "%.*s", len
, ptr
);
4955 /* ignore case according to p_ic, p_scs and pat */
4956 regmatch
.rm_ic
= ignorecase(pat
);
4957 regmatch
.regprog
= vim_regcomp(pat
, p_magic
? RE_MAGIC
: 0);
4959 if (regmatch
.regprog
== NULL
)
4962 inc_opt
= (*curbuf
->b_p_inc
== NUL
) ? p_inc
: curbuf
->b_p_inc
;
4963 if (*inc_opt
!= NUL
)
4965 incl_regmatch
.regprog
= vim_regcomp(inc_opt
, p_magic
? RE_MAGIC
: 0);
4966 if (incl_regmatch
.regprog
== NULL
)
4968 incl_regmatch
.rm_ic
= FALSE
; /* don't ignore case in incl. pat. */
4970 if (type
== FIND_DEFINE
&& (*curbuf
->b_p_def
!= NUL
|| *p_def
!= NUL
))
4972 def_regmatch
.regprog
= vim_regcomp(*curbuf
->b_p_def
== NUL
4973 ? p_def
: curbuf
->b_p_def
, p_magic
? RE_MAGIC
: 0);
4974 if (def_regmatch
.regprog
== NULL
)
4976 def_regmatch
.rm_ic
= FALSE
; /* don't ignore case in define pat. */
4978 files
= (SearchedFile
*)lalloc_clear((long_u
)
4979 (max_path_depth
* sizeof(SearchedFile
)), TRUE
);
4982 old_files
= max_path_depth
;
4983 depth
= depth_displayed
= -1;
4986 if (end_lnum
> curbuf
->b_ml
.ml_line_count
)
4987 end_lnum
= curbuf
->b_ml
.ml_line_count
;
4988 if (lnum
> end_lnum
) /* do at least one line */
4990 line
= ml_get(lnum
);
4994 if (incl_regmatch
.regprog
!= NULL
4995 && vim_regexec(&incl_regmatch
, line
, (colnr_T
)0))
4997 char_u
*p_fname
= (curr_fname
== curbuf
->b_fname
)
4998 ? curbuf
->b_ffname
: curr_fname
;
5000 if (inc_opt
!= NULL
&& strstr((char *)inc_opt
, "\\zs") != NULL
)
5001 /* Use text from '\zs' to '\ze' (or end) of 'include'. */
5002 new_fname
= find_file_name_in_path(incl_regmatch
.startp
[0],
5003 (int)(incl_regmatch
.endp
[0] - incl_regmatch
.startp
[0]),
5004 FNAME_EXP
|FNAME_INCL
|FNAME_REL
, 1L, p_fname
);
5006 /* Use text after match with 'include'. */
5007 new_fname
= file_name_in_line(incl_regmatch
.endp
[0], 0,
5008 FNAME_EXP
|FNAME_INCL
|FNAME_REL
, 1L, p_fname
, NULL
);
5009 already_searched
= FALSE
;
5010 if (new_fname
!= NULL
)
5012 /* Check whether we have already searched in this file */
5017 if (i
== max_path_depth
)
5019 if (fullpathcmp(new_fname
, files
[i
].name
, TRUE
) & FPC_SAME
)
5021 if (type
!= CHECK_PATH
&&
5022 action
== ACTION_SHOW_ALL
&& files
[i
].matched
)
5024 msg_putchar('\n'); /* cursor below last one */
5025 if (!got_int
) /* don't display if 'q'
5029 msg_home_replace_hl(new_fname
);
5030 MSG_PUTS(_(" (includes previously listed match)"));
5034 vim_free(new_fname
);
5036 already_searched
= TRUE
;
5042 if (type
== CHECK_PATH
&& (action
== ACTION_SHOW_ALL
5043 || (new_fname
== NULL
&& !already_searched
)))
5046 msg_putchar('\n'); /* cursor below last one */
5049 gotocmdline(TRUE
); /* cursor at status line */
5050 MSG_PUTS_TITLE(_("--- Included files "));
5051 if (action
!= ACTION_SHOW_ALL
)
5052 MSG_PUTS_TITLE(_("not found "));
5053 MSG_PUTS_TITLE(_("in path ---\n"));
5056 while (depth_displayed
< depth
&& !got_int
)
5059 for (i
= 0; i
< depth_displayed
; i
++)
5061 msg_home_replace(files
[depth_displayed
].name
);
5064 if (!got_int
) /* don't display if 'q' typed
5065 for "--more--" message */
5067 for (i
= 0; i
<= depth_displayed
; i
++)
5069 if (new_fname
!= NULL
)
5071 /* using "new_fname" is more reliable, e.g., when
5072 * 'includeexpr' is set. */
5073 msg_outtrans_attr(new_fname
, hl_attr(HLF_D
));
5078 * Isolate the file name.
5079 * Include the surrounding "" or <> if present.
5081 for (p
= incl_regmatch
.endp
[0]; !vim_isfilec(*p
); p
++)
5083 for (i
= 0; vim_isfilec(p
[i
]); i
++)
5087 /* Nothing found, use the rest of the line. */
5088 p
= incl_regmatch
.endp
[0];
5093 if (p
[-1] == '"' || p
[-1] == '<')
5098 if (p
[i
] == '"' || p
[i
] == '>')
5103 msg_outtrans_attr(p
, hl_attr(HLF_D
));
5107 if (new_fname
== NULL
&& action
== ACTION_SHOW_ALL
)
5109 if (already_searched
)
5110 MSG_PUTS(_(" (Already listed)"));
5112 MSG_PUTS(_(" NOT FOUND"));
5115 out_flush(); /* output each line directly */
5118 if (new_fname
!= NULL
)
5120 /* Push the new file onto the file stack */
5121 if (depth
+ 1 == old_files
)
5123 bigger
= (SearchedFile
*)lalloc((long_u
)(
5124 max_path_depth
* 2 * sizeof(SearchedFile
)), TRUE
);
5127 for (i
= 0; i
<= depth
; i
++)
5128 bigger
[i
] = files
[i
];
5129 for (i
= depth
+ 1; i
< old_files
+ max_path_depth
; i
++)
5131 bigger
[i
].fp
= NULL
;
5132 bigger
[i
].name
= NULL
;
5134 bigger
[i
].matched
= FALSE
;
5136 for (i
= old_files
; i
< max_path_depth
; i
++)
5137 bigger
[i
+ max_path_depth
] = files
[i
];
5138 old_files
+= max_path_depth
;
5139 max_path_depth
*= 2;
5144 if ((files
[depth
+ 1].fp
= mch_fopen((char *)new_fname
, "r"))
5146 vim_free(new_fname
);
5149 if (++depth
== old_files
)
5152 * lalloc() for 'bigger' must have failed above. We
5153 * will forget one of our already visited files now.
5155 vim_free(files
[old_files
].name
);
5158 files
[depth
].name
= curr_fname
= new_fname
;
5159 files
[depth
].lnum
= 0;
5160 files
[depth
].matched
= FALSE
;
5161 #ifdef FEAT_INS_EXPAND
5162 if (action
== ACTION_EXPAND
)
5164 msg_hist_off
= TRUE
; /* reset in msg_trunc_attr() */
5165 vim_snprintf((char*)IObuff
, IOSIZE
,
5166 _("Scanning included file: %s"),
5168 msg_trunc_attr(IObuff
, TRUE
, hl_attr(HLF_R
));
5175 smsg((char_u
*)_("Searching included file %s"),
5186 * Check if the line is a define (type == FIND_DEFINE)
5190 define_matched
= FALSE
;
5191 if (def_regmatch
.regprog
!= NULL
5192 && vim_regexec(&def_regmatch
, line
, (colnr_T
)0))
5195 * Pattern must be first identifier after 'define', so skip
5196 * to that position before checking for match of pattern. Also
5197 * don't let it match beyond the end of this identifier.
5199 p
= def_regmatch
.endp
[0];
5200 while (*p
&& !vim_iswordc(*p
))
5202 define_matched
= TRUE
;
5206 * Look for a match. Don't do this if we are looking for a
5207 * define and this line didn't match define_prog above.
5209 if (def_regmatch
.regprog
== NULL
|| define_matched
)
5212 #ifdef FEAT_INS_EXPAND
5213 || (compl_cont_status
& CONT_SOL
)
5217 /* compare the first "len" chars from "ptr" */
5218 startp
= skipwhite(p
);
5220 matched
= !MB_STRNICMP(startp
, ptr
, len
);
5222 matched
= !STRNCMP(startp
, ptr
, len
);
5223 if (matched
&& define_matched
&& whole
5224 && vim_iswordc(startp
[len
]))
5227 else if (regmatch
.regprog
!= NULL
5228 && vim_regexec(®match
, line
, (colnr_T
)(p
- line
)))
5231 startp
= regmatch
.startp
[0];
5233 * Check if the line is not a comment line (unless we are
5234 * looking for a define). A line starting with "# define"
5235 * is not considered to be a comment line.
5237 if (!define_matched
&& skip_comments
)
5239 #ifdef FEAT_COMMENTS
5240 if ((*line
!= '#' ||
5241 STRNCMP(skipwhite(line
+ 1), "define", 6) != 0)
5242 && get_leader_len(line
, NULL
, FALSE
))
5246 * Also check for a "/ *" or "/ /" before the match.
5247 * Skips lines like "int backwards; / * normal index
5248 * * /" when looking for "normal".
5249 * Note: Doesn't skip "/ *" in comments.
5251 p
= skipwhite(line
);
5253 || (p
[0] == '/' && p
[1] == '*') || p
[0] == '*')
5255 for (p
= line
; *p
&& p
< startp
; ++p
)
5259 && (p
[1] == '*' || p
[1] == '/'))
5262 /* After "//" all text is comment */
5267 else if (!matched
&& p
[0] == '*' && p
[1] == '/')
5269 /* Can find match after "* /". */
5280 #ifdef FEAT_INS_EXPAND
5281 if (action
== ACTION_EXPAND
)
5287 if (depth
== -1 && lnum
== curwin
->w_cursor
.lnum
)
5291 if (compl_cont_status
& CONT_ADDING
)
5296 p
= find_word_start(p
);
5298 p
= find_word_end(p
);
5301 if ((compl_cont_status
& CONT_ADDING
) && i
== compl_length
)
5303 /* IOSIZE > compl_length, so the STRNCPY works */
5304 STRNCPY(IObuff
, aux
, i
);
5306 /* Get the next line: when "depth" < 0 from the current
5307 * buffer, otherwise from the included file. Jump to
5308 * exit_matched when past the last line. */
5311 if (lnum
>= end_lnum
)
5313 line
= ml_get(++lnum
);
5315 else if (vim_fgets(line
= file_line
,
5316 LSIZE
, files
[depth
].fp
))
5319 /* we read a line, set "already" to check this "line" later
5320 * if depth >= 0 we'll increase files[depth].lnum far
5321 * bellow -- Acevedo */
5322 already
= aux
= p
= skipwhite(line
);
5323 p
= find_word_start(p
);
5324 p
= find_word_end(p
);
5327 if (*aux
!= ')' && IObuff
[i
-1] != TAB
)
5329 if (IObuff
[i
-1] != ' ')
5331 /* IObuf =~ "\(\k\|\i\).* ", thus i >= 2*/
5333 && (IObuff
[i
-2] == '.'
5334 || (vim_strchr(p_cpo
, CPO_JOINSP
) == NULL
5335 && (IObuff
[i
-2] == '?'
5336 || IObuff
[i
-2] == '!'))))
5339 /* copy as much as possible of the new word */
5340 if (p
- aux
>= IOSIZE
- i
)
5341 p
= aux
+ IOSIZE
- i
- 1;
5342 STRNCPY(IObuff
+ i
, aux
, p
- aux
);
5343 i
+= (int)(p
- aux
);
5344 reuse
|= CONT_S_IPOS
;
5349 if (i
== compl_length
)
5353 add_r
= ins_compl_add_infercase(aux
, i
, p_ic
,
5354 curr_fname
== curbuf
->b_fname
? NULL
: curr_fname
,
5357 /* if dir was BACKWARD then honor it just once */
5359 else if (add_r
== FAIL
)
5364 if (action
== ACTION_SHOW_ALL
)
5368 gotocmdline(TRUE
); /* cursor at status line */
5369 if (curr_fname
!= prev_fname
)
5372 msg_putchar('\n'); /* cursor below last one */
5373 if (!got_int
) /* don't display if 'q' typed
5374 at "--more--" message */
5375 msg_home_replace_hl(curr_fname
);
5376 prev_fname
= curr_fname
;
5380 show_pat_in_path(line
, type
, TRUE
, action
,
5381 (depth
== -1) ? NULL
: files
[depth
].fp
,
5382 (depth
== -1) ? &lnum
: &files
[depth
].lnum
,
5385 /* Set matched flag for this file and all the ones that
5387 for (i
= 0; i
<= depth
; ++i
)
5388 files
[i
].matched
= TRUE
;
5390 else if (--count
<= 0)
5393 if (depth
== -1 && lnum
== curwin
->w_cursor
.lnum
5394 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
5395 && g_do_tagpreview
== 0
5398 EMSG(_("E387: Match is on current line"));
5399 else if (action
== ACTION_SHOW
)
5401 show_pat_in_path(line
, type
, did_show
, action
,
5402 (depth
== -1) ? NULL
: files
[depth
].fp
,
5403 (depth
== -1) ? &lnum
: &files
[depth
].lnum
, 1L);
5409 need_mouse_correct
= TRUE
;
5411 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
5412 /* ":psearch" uses the preview window */
5413 if (g_do_tagpreview
!= 0)
5415 curwin_save
= curwin
;
5416 prepare_tagpreview(TRUE
);
5419 if (action
== ACTION_SPLIT
)
5422 if (win_split(0, 0) == FAIL
)
5425 #ifdef FEAT_SCROLLBIND
5426 curwin
->w_p_scb
= FALSE
;
5431 /* match in current file */
5432 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
5433 if (g_do_tagpreview
!= 0)
5435 if (getfile(0, curwin_save
->w_buffer
->b_fname
,
5436 NULL
, TRUE
, lnum
, FALSE
) > 0)
5437 break; /* failed to jump to file */
5442 curwin
->w_cursor
.lnum
= lnum
;
5446 if (getfile(0, files
[depth
].name
, NULL
, TRUE
,
5447 files
[depth
].lnum
, FALSE
) > 0)
5448 break; /* failed to jump to file */
5449 /* autocommands may have changed the lnum, we don't
5451 curwin
->w_cursor
.lnum
= files
[depth
].lnum
;
5454 if (action
!= ACTION_SHOW
)
5456 curwin
->w_cursor
.col
= (colnr_T
)(startp
- line
);
5457 curwin
->w_set_curswant
= TRUE
;
5460 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
5461 if (g_do_tagpreview
!= 0
5462 && curwin
!= curwin_save
&& win_valid(curwin_save
))
5464 /* Return cursor to where we were */
5466 redraw_later(VALID
);
5467 win_enter(curwin_save
, TRUE
);
5472 #ifdef FEAT_INS_EXPAND
5476 /* look for other matches in the rest of the line if we
5477 * are not at the end of it already */
5478 if (def_regmatch
.regprog
== NULL
5479 #ifdef FEAT_INS_EXPAND
5480 && action
== ACTION_EXPAND
5481 && !(compl_cont_status
& CONT_SOL
)
5484 && *(p
= startp
+ 1) != NUL
)
5488 #ifdef FEAT_INS_EXPAND
5489 if (action
== ACTION_EXPAND
)
5490 ins_compl_check_keys(30);
5491 if (got_int
|| compl_interrupted
)
5498 * Read the next line. When reading an included file and encountering
5499 * end-of-file, close the file and continue in the file that included
5502 while (depth
>= 0 && !already
5503 && vim_fgets(line
= file_line
, LSIZE
, files
[depth
].fp
))
5505 fclose(files
[depth
].fp
);
5507 files
[old_files
].name
= files
[depth
].name
;
5508 files
[old_files
].matched
= files
[depth
].matched
;
5510 curr_fname
= (depth
== -1) ? curbuf
->b_fname
5511 : files
[depth
].name
;
5512 if (depth
< depth_displayed
)
5513 depth_displayed
= depth
;
5515 if (depth
>= 0) /* we could read the line */
5516 files
[depth
].lnum
++;
5519 if (++lnum
> end_lnum
)
5521 line
= ml_get(lnum
);
5525 /* End of big for (;;) loop. */
5527 /* Close any files that are still open. */
5528 for (i
= 0; i
<= depth
; i
++)
5530 fclose(files
[i
].fp
);
5531 vim_free(files
[i
].name
);
5533 for (i
= old_files
; i
< max_path_depth
; i
++)
5534 vim_free(files
[i
].name
);
5537 if (type
== CHECK_PATH
)
5541 if (action
!= ACTION_SHOW_ALL
)
5542 MSG(_("All included files were found"));
5544 MSG(_("No included files"));
5548 #ifdef FEAT_INS_EXPAND
5549 && action
!= ACTION_EXPAND
5553 #ifdef FEAT_INS_EXPAND
5554 if (got_int
|| compl_interrupted
)
5559 else if (type
== FIND_DEFINE
)
5560 EMSG(_("E388: Couldn't find definition"));
5562 EMSG(_("E389: Couldn't find pattern"));
5564 if (action
== ACTION_SHOW
|| action
== ACTION_SHOW_ALL
)
5568 vim_free(file_line
);
5569 vim_free(regmatch
.regprog
);
5570 vim_free(incl_regmatch
.regprog
);
5571 vim_free(def_regmatch
.regprog
);
5574 /* Restore previous file munging state. */
5575 __riscosify_control
= previous_munging
;
5580 show_pat_in_path(line
, type
, did_show
, action
, fp
, lnum
, count
)
5592 msg_putchar('\n'); /* cursor below last one */
5593 else if (!msg_silent
)
5594 gotocmdline(TRUE
); /* cursor at status line */
5595 if (got_int
) /* 'q' typed at "--more--" message */
5599 p
= line
+ STRLEN(line
) - 1;
5602 /* We used fgets(), so get rid of newline at end */
5603 if (p
>= line
&& *p
== '\n')
5605 if (p
>= line
&& *p
== '\r')
5609 if (action
== ACTION_SHOW_ALL
)
5611 sprintf((char *)IObuff
, "%3ld: ", count
); /* show match nr */
5613 sprintf((char *)IObuff
, "%4ld", *lnum
); /* show line nr */
5614 /* Highlight line numbers */
5615 msg_puts_attr(IObuff
, hl_attr(HLF_N
));
5618 msg_prt_line(line
, FALSE
);
5619 out_flush(); /* show one line at a time */
5621 /* Definition continues until line that doesn't end with '\' */
5622 if (got_int
|| type
!= FIND_DEFINE
|| p
< line
|| *p
!= '\\')
5627 if (vim_fgets(line
, LSIZE
, fp
)) /* end of file */
5633 if (++*lnum
> curbuf
->b_ml
.ml_line_count
)
5635 line
= ml_get(*lnum
);
5644 read_viminfo_search_pattern(virp
, force
)
5652 int off_line
= FALSE
;
5655 int setlast
= FALSE
;
5656 #ifdef FEAT_SEARCH_EXTRA
5657 static int hlsearch_on
= FALSE
;
5663 * "/pat", "&pat": search/subst. pat
5664 * "~/pat", "~&pat": last used search/subst. pat
5666 * "~h", "~H": hlsearch highlighting off/on
5667 * "~<magic><smartcase><line><end><off><last><which>pat"
5668 * <magic>: 'm' off, 'M' on
5669 * <smartcase>: 's' off, 'S' on
5670 * <line>: 'L' line offset, 'l' char offset
5671 * <end>: 'E' from end, 'e' from start
5672 * <off>: decimal, offset
5673 * <last>: '~' last used pattern
5674 * <which>: '/' search pat, '&' subst. pat
5676 lp
= virp
->vir_line
;
5677 if (lp
[0] == '~' && (lp
[1] == 'm' || lp
[1] == 'M')) /* new line type */
5679 if (lp
[1] == 'M') /* magic on */
5686 off_end
= SEARCH_END
;
5688 off
= getdigits(&lp
);
5690 if (lp
[0] == '~') /* use this pattern for last-used pattern */
5697 else if (lp
[0] == '&')
5699 #ifdef FEAT_SEARCH_EXTRA
5700 else if (lp
[0] == 'h') /* ~h: 'hlsearch' highlighting off */
5701 hlsearch_on
= FALSE
;
5702 else if (lp
[0] == 'H') /* ~H: 'hlsearch' highlighting on */
5707 if (force
|| spats
[idx
].pat
== NULL
)
5709 val
= viminfo_readstring(virp
, (int)(lp
- virp
->vir_line
+ 1),
5713 set_last_search_pat(val
, idx
, magic
, setlast
);
5715 spats
[idx
].no_scs
= no_scs
;
5716 spats
[idx
].off
.line
= off_line
;
5717 spats
[idx
].off
.end
= off_end
;
5718 spats
[idx
].off
.off
= off
;
5719 #ifdef FEAT_SEARCH_EXTRA
5721 no_hlsearch
= !hlsearch_on
;
5726 return viminfo_readline(virp
);
5730 write_viminfo_search_pattern(fp
)
5733 if (get_viminfo_parameter('/') != 0)
5735 #ifdef FEAT_SEARCH_EXTRA
5736 fprintf(fp
, "\n# hlsearch on (H) or off (h):\n~%c",
5737 (no_hlsearch
|| find_viminfo_parameter('h') != NULL
) ? 'h' : 'H');
5739 wvsp_one(fp
, RE_SEARCH
, "", '/');
5740 wvsp_one(fp
, RE_SUBST
, _("Substitute "), '&');
5745 wvsp_one(fp
, idx
, s
, sc
)
5746 FILE *fp
; /* file to write to */
5747 int idx
; /* spats[] index */
5748 char *s
; /* search pat */
5749 int sc
; /* dir char */
5751 if (spats
[idx
].pat
!= NULL
)
5753 fprintf(fp
, _("\n# Last %sSearch Pattern:\n~"), s
);
5754 /* off.dir is not stored, it's reset to forward */
5755 fprintf(fp
, "%c%c%c%c%ld%s%c",
5756 spats
[idx
].magic
? 'M' : 'm', /* magic */
5757 spats
[idx
].no_scs
? 's' : 'S', /* smartcase */
5758 spats
[idx
].off
.line
? 'L' : 'l', /* line offset */
5759 spats
[idx
].off
.end
? 'E' : 'e', /* offset from end */
5760 spats
[idx
].off
.off
, /* offset */
5761 last_idx
== idx
? "~" : "", /* last used pat */
5763 viminfo_writestring(fp
, spats
[idx
].pat
);
5766 #endif /* FEAT_VIMINFO */