![[BACK]](/icons/back.gif){kind=icon}
Return to search.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim|
Return to search.c CVS log | Up to [local] / src / usr.bin / vim |
1.1 downsj 1: /* $OpenBSD$ */
2: /* vi:set ts=4 sw=4:
3: *
4: * VIM - Vi IMproved by Bram Moolenaar
5: *
6: * Do ":help uganda" in Vim to read copying and usage conditions.
7: * Do ":help credits" in Vim to see a list of people who contributed.
8: */
9: /*
10: * search.c: code for normal mode searching commands
11: */
12:
13: #include "vim.h"
14: #include "globals.h"
15: #include "proto.h"
16: #include "option.h"
17: #include "ops.h" /* for op_inclusive */
18:
19: /* modified Henry Spencer's regular expression routines */
20: #include "regexp.h"
21:
22: static int inmacro __ARGS((char_u *, char_u *));
23: static int cls __ARGS((void));
24: static int skip_chars __ARGS((int, int));
25: static void back_in_line __ARGS((void));
26: static void find_first_blank __ARGS((FPOS *));
27: static void show_pat_in_path __ARGS((char_u *, int,
28: int, int, FILE *, linenr_t *, long));
29: static void give_warning __ARGS((char_u *));
30:
31: static char_u *top_bot_msg = (char_u *)"search hit TOP, continuing at BOTTOM";
32: static char_u *bot_top_msg = (char_u *)"search hit BOTTOM, continuing at TOP";
33:
34: /*
35: * This file contains various searching-related routines. These fall into
36: * three groups:
37: * 1. string searches (for /, ?, n, and N)
38: * 2. character searches within a single line (for f, F, t, T, etc)
39: * 3. "other" kinds of searches like the '%' command, and 'word' searches.
40: */
41:
42: /*
43: * String searches
44: *
45: * The string search functions are divided into two levels:
46: * lowest: searchit(); called by do_search() and edit().
47: * Highest: do_search(); changes curwin->w_cursor, called by normal().
48: *
49: * The last search pattern is remembered for repeating the same search.
50: * This pattern is shared between the :g, :s, ? and / commands.
51: * This is in myregcomp().
52: *
53: * The actual string matching is done using a heavily modified version of
54: * Henry Spencer's regular expression library.
55: */
56:
57: /*
58: * Two search patterns are remembered: One for the :substitute command and
59: * one for other searches. last_pattern points to the one that was
60: * used the last time.
61: */
62: static char_u *search_pattern = NULL;
63: static int search_magic = TRUE;
64: static int search_no_scs = FALSE;
65: static char_u *subst_pattern = NULL;
66: static int subst_magic = TRUE;
67: static int subst_no_scs = FALSE;
68: static char_u *last_pattern = NULL;
69: static int last_magic = TRUE;
70: static int last_no_scs = FALSE;
71: static char_u *mr_pattern = NULL; /* pattern used by myregcomp() */
72:
73: static int want_start; /* looking for start of line? */
74:
75: /*
76: * Type used by find_pattern_in_path() to remember which included files have
77: * been searched already.
78: */
79: typedef struct SearchedFile
80: {
81: FILE *fp; /* File pointer */
82: char_u *name; /* Full name of file */
83: linenr_t lnum; /* Line we were up to in file */
84: int matched; /* Found a match in this file */
85: } SearchedFile;
86:
87: /*
88: * translate search pattern for vim_regcomp()
89: *
90: * sub_cmd == RE_SEARCH: save pat in search_pattern (normal search command)
91: * sub_cmd == RE_SUBST: save pat in subst_pattern (:substitute command)
92: * sub_cmd == RE_BOTH: save pat in both patterns (:global command)
93: * which_pat == RE_SEARCH: use previous search pattern if "pat" is NULL
94: * which_pat == RE_SUBST: use previous sustitute pattern if "pat" is NULL
95: * which_pat == RE_LAST: use last used pattern if "pat" is NULL
96: * options & SEARCH_HIS: put search string in history
97: * options & SEARCH_KEEP: keep previous search pattern
98: *
99: */
100: regexp *
101: myregcomp(pat, sub_cmd, which_pat, options)
102: char_u *pat;
103: int sub_cmd;
104: int which_pat;
105: int options;
106: {
107: rc_did_emsg = FALSE;
108: reg_magic = p_magic;
109: if (pat == NULL || *pat == NUL) /* use previous search pattern */
110: {
111: if (which_pat == RE_SEARCH)
112: {
113: if (search_pattern == NULL)
114: {
115: emsg(e_noprevre);
116: rc_did_emsg = TRUE;
117: return (regexp *) NULL;
118: }
119: pat = search_pattern;
120: reg_magic = search_magic;
121: no_smartcase = search_no_scs;
122: }
123: else if (which_pat == RE_SUBST)
124: {
125: if (subst_pattern == NULL)
126: {
127: emsg(e_nopresub);
128: rc_did_emsg = TRUE;
129: return (regexp *) NULL;
130: }
131: pat = subst_pattern;
132: reg_magic = subst_magic;
133: no_smartcase = subst_no_scs;
134: }
135: else /* which_pat == RE_LAST */
136: {
137: if (last_pattern == NULL)
138: {
139: emsg(e_noprevre);
140: rc_did_emsg = TRUE;
141: return (regexp *) NULL;
142: }
143: pat = last_pattern;
144: reg_magic = last_magic;
145: no_smartcase = last_no_scs;
146: }
147: }
148: else if (options & SEARCH_HIS)
149: add_to_history(1, pat); /* put new pattern in history */
150:
151: mr_pattern = pat;
152:
153: /*
154: * save the currently used pattern in the appropriate place,
155: * unless the pattern should not be remembered
156: */
157: if (!(options & SEARCH_KEEP))
158: {
159: /*
160: * search or global command
161: */
162: if (sub_cmd == RE_SEARCH || sub_cmd == RE_BOTH)
163: {
164: if (search_pattern != pat)
165: {
166: vim_free(search_pattern);
167: search_pattern = strsave(pat);
168: last_pattern = search_pattern;
169: search_magic = reg_magic;
170: last_magic = reg_magic; /* Magic sticks with the r.e. */
171: search_no_scs = no_smartcase;
172: last_no_scs = no_smartcase;
173: }
174: }
175: /*
176: * substitute or global command
177: */
178: if (sub_cmd == RE_SUBST || sub_cmd == RE_BOTH)
179: {
180: if (subst_pattern != pat)
181: {
182: vim_free(subst_pattern);
183: subst_pattern = strsave(pat);
184: last_pattern = subst_pattern;
185: subst_magic = reg_magic;
186: last_magic = reg_magic; /* Magic sticks with the r.e. */
187: subst_no_scs = no_smartcase;
188: last_no_scs = no_smartcase;
189: }
190: }
191: }
192:
193: want_start = (*pat == '^'); /* looking for start of line? */
194: set_reg_ic(pat); /* tell the vim_regexec routine how to search */
195: return vim_regcomp(pat);
196: }
197:
198: /*
199: * Set reg_ic according to p_ic, p_scs and the search pattern.
200: */
201: void
202: set_reg_ic(pat)
203: char_u *pat;
204: {
205: char_u *p;
206:
207: reg_ic = p_ic;
208: if (!no_smartcase && p_scs
209: #ifdef INSERT_EXPAND
210: && !(ctrl_x_mode && curbuf->b_p_inf)
211: #endif
212: )
213: {
214: /* don't ignore case if pattern has uppercase */
215: for (p = pat; *p; )
216: if (isupper(*p++))
217: reg_ic = FALSE;
218: }
219: no_smartcase = FALSE;
220: }
221:
222: /*
223: * lowest level search function.
224: * Search for 'count'th occurrence of 'str' in direction 'dir'.
225: * Start at position 'pos' and return the found position in 'pos'.
226: *
227: * if (options & SEARCH_MSG) == 0 don't give any messages
228: * if (options & SEARCH_MSG) == SEARCH_NFMSG don't give 'notfound' messages
229: * if (options & SEARCH_MSG) == SEARCH_MSG give all messages
230: * if (options & SEARCH_HIS) put search pattern in history
231: * if (options & SEARCH_END) return position at end of match
232: * if (options & SEARCH_START) accept match at pos itself
233: * if (options & SEARCH_KEEP) keep previous search pattern
234: *
235: * Return OK for success, FAIL for failure.
236: */
237: int
238: searchit(pos, dir, str, count, options, which_pat)
239: FPOS *pos;
240: int dir;
241: char_u *str;
242: long count;
243: int options;
244: int which_pat;
245: {
246: int found;
247: linenr_t lnum; /* no init to shut up Apollo cc */
248: regexp *prog;
249: char_u *ptr;
250: register char_u *match = NULL, *matchend = NULL; /* init for GCC */
251: int loop;
252: FPOS start_pos;
253: int at_first_line;
254: int extra_col;
255: int match_ok;
256: char_u *p;
257:
258: if ((prog = myregcomp(str, RE_SEARCH, which_pat,
259: (options & (SEARCH_HIS + SEARCH_KEEP)))) == NULL)
260: {
261: if ((options & SEARCH_MSG) && !rc_did_emsg)
262: emsg2((char_u *)"Invalid search string: %s", mr_pattern);
263: return FAIL;
264: }
265:
266: if (options & SEARCH_START)
267: extra_col = 0;
268: else
269: extra_col = 1;
270:
271:
272: /*
273: * find the string
274: */
275: do /* loop for count */
276: {
277: start_pos = *pos; /* remember start pos for detecting no match */
278: found = 0; /* default: not found */
279:
280: /*
281: * Start searching in current line, unless searching backwards and
282: * we're in column 0 or searching forward and we're past the end of
283: * the line
284: */
285: if (dir == BACKWARD && start_pos.col == 0)
286: {
287: lnum = pos->lnum - 1;
288: at_first_line = FALSE;
289: }
290: else
291: {
292: lnum = pos->lnum;
293: at_first_line = TRUE;
294: }
295:
296: for (loop = 0; loop <= 1; ++loop) /* loop twice if 'wrapscan' set */
297: {
298: for ( ; lnum > 0 && lnum <= curbuf->b_ml.ml_line_count;
299: lnum += dir, at_first_line = FALSE)
300: {
301: ptr = ml_get(lnum);
302: /* forward search, first line */
303: if (dir == FORWARD && at_first_line && start_pos.col > 0 &&
304: want_start)
305: continue; /* match not possible */
306:
307: /*
308: * Look for a match somewhere in the line.
309: */
310: if (vim_regexec(prog, ptr, TRUE))
311: {
312: match = prog->startp[0];
313: matchend = prog->endp[0];
314:
315: /*
316: * Forward search in the first line: match should be after
317: * the start position. If not, continue at the end of the
318: * match (this is vi compatible).
319: */
320: if (dir == FORWARD && at_first_line)
321: {
322: match_ok = TRUE;
323: /*
324: * When *match == NUL the cursor will be put one back
325: * afterwards, compare with that position, otherwise
326: * "/$" will get stuck on end of line. Same for
327: * matchend.
328: */
329: while ((options & SEARCH_END) ?
330: ((int)(matchend - ptr) - 1 - (int)(*matchend == NUL) <
331: (int)start_pos.col + extra_col) :
332: ((int)(match - ptr) - (int)(*match == NUL) <
333: (int)start_pos.col + extra_col))
334: {
335: /*
336: * If vi-compatible searching, continue at the end
337: * of the match, otherwise continue one position
338: * forward.
339: */
340: if (vim_strchr(p_cpo, CPO_SEARCH) != NULL)
341: {
342: p = matchend;
343: if (match == p && *p != NUL)
344: ++p;
345: }
346: else
347: {
348: p = match;
349: if (*p != NUL)
350: ++p;
351: }
352: if (*p != NUL && vim_regexec(prog, p, FALSE))
353: {
354: match = prog->startp[0];
355: matchend = prog->endp[0];
356: }
357: else
358: {
359: match_ok = FALSE;
360: break;
361: }
362: }
363: if (!match_ok)
364: continue;
365: }
366: if (dir == BACKWARD && !want_start)
367: {
368: /*
369: * Now, if there are multiple matches on this line,
370: * we have to get the last one. Or the last one before
371: * the cursor, if we're on that line.
372: * When putting the new cursor at the end, compare
373: * relative to the end of the match.
374: */
375: match_ok = FALSE;
376: for (;;)
377: {
378: if (!at_first_line || ((options & SEARCH_END) ?
379: ((prog->endp[0] - ptr) - 1 + extra_col
380: <= (int)start_pos.col) :
381: ((prog->startp[0] - ptr) + extra_col
382: <= (int)start_pos.col)))
383: {
384: match_ok = TRUE;
385: match = prog->startp[0];
386: matchend = prog->endp[0];
387: }
388: else
389: break;
390: /*
391: * If vi-compatible searching, continue at the end
392: * of the match, otherwise continue one position
393: * forward.
394: */
395: if (vim_strchr(p_cpo, CPO_SEARCH) != NULL)
396: {
397: p = matchend;
398: if (p == match && *p != NUL)
399: ++p;
400: }
401: else
402: {
403: p = match;
404: if (*p != NUL)
405: ++p;
406: }
407: if (*p == NUL || !vim_regexec(prog, p, (int)FALSE))
408: break;
409: }
410:
411: /*
412: * If there is only a match after the cursor, skip
413: * this match.
414: */
415: if (!match_ok)
416: continue;
417: }
418:
419: pos->lnum = lnum;
420: if (options & SEARCH_END && !(options & SEARCH_NOOF))
421: pos->col = (int) (matchend - ptr - 1);
422: else
423: pos->col = (int) (match - ptr);
424: found = 1;
425: break;
426: }
427: line_breakcheck(); /* stop if ctrl-C typed */
428: if (got_int)
429: break;
430:
431: if (loop && lnum == start_pos.lnum)
432: break; /* if second loop, stop where started */
433: }
434: at_first_line = FALSE;
435:
436: /*
437: * stop the search if wrapscan isn't set, after an interrupt and
438: * after a match
439: */
440: if (!p_ws || got_int || found)
441: break;
442:
443: /*
444: * If 'wrapscan' is set we continue at the other end of the file.
445: * If 'shortmess' does not contain 's', we give a message.
446: * This message is also remembered in keep_msg for when the screen
447: * is redrawn. The keep_msg is cleared whenever another message is
448: * written.
449: */
450: if (dir == BACKWARD) /* start second loop at the other end */
451: {
452: lnum = curbuf->b_ml.ml_line_count;
453: if (!shortmess(SHM_SEARCH) && (options & SEARCH_MSG))
454: give_warning(top_bot_msg);
455: }
456: else
457: {
458: lnum = 1;
459: if (!shortmess(SHM_SEARCH) && (options & SEARCH_MSG))
460: give_warning(bot_top_msg);
461: }
462: }
463: if (got_int)
464: break;
465: }
466: while (--count > 0 && found); /* stop after count matches or no match */
467:
468: vim_free(prog);
469:
470: if (!found) /* did not find it */
471: {
472: if (got_int)
473: emsg(e_interr);
474: else if ((options & SEARCH_MSG) == SEARCH_MSG)
475: {
476: if (p_ws)
477: EMSG2("Pattern not found: %s", mr_pattern);
478: else if (lnum == 0)
479: EMSG2("search hit TOP without match for: %s", mr_pattern);
480: else
481: EMSG2("search hit BOTTOM without match for: %s", mr_pattern);
482: }
483: return FAIL;
484: }
485: search_match_len = matchend - match;
486:
487: return OK;
488: }
489:
490: /*
491: * Highest level string search function.
492: * Search for the 'count'th occurence of string 'str' in direction 'dirc'
493: * If 'dirc' is 0: use previous dir.
494: * If 'str' is NULL or empty : use previous string.
495: * If 'options & SEARCH_REV' : go in reverse of previous dir.
496: * If 'options & SEARCH_ECHO': echo the search command and handle options
497: * If 'options & SEARCH_MSG' : may give error message
498: * If 'options & SEARCH_OPT' : interpret optional flags
499: * If 'options & SEARCH_HIS' : put search pattern in history
500: * If 'options & SEARCH_NOOF': don't add offset to position
501: * If 'options & SEARCH_MARK': set previous context mark
502: * If 'options & SEARCH_KEEP': keep previous search pattern
503: *
504: * Careful: If lastoffline == TRUE and lastoff == 0 this makes the
505: * movement linewise without moving the match position.
506: *
507: * return 0 for failure, 1 for found, 2 for found and line offset added
508: */
509: int
510: do_search(dirc, str, count, options)
511: int dirc;
512: char_u *str;
513: long count;
514: int options;
515: {
516: FPOS pos; /* position of the last match */
517: char_u *searchstr;
518: static int lastsdir = '/'; /* previous search direction */
519: static int lastoffline;/* previous/current search has line offset */
520: static int lastend; /* previous/current search set cursor at end */
521: static long lastoff; /* previous/current line or char offset */
522: int old_lastsdir;
523: int old_lastoffline;
524: int old_lastend;
525: long old_lastoff;
526: int retval; /* Return value */
527: register char_u *p;
528: register long c;
529: char_u *dircp;
530: int i = 0; /* init for GCC */
531:
532: /*
533: * A line offset is not remembered, this is vi compatible.
534: */
535: if (lastoffline && vim_strchr(p_cpo, CPO_LINEOFF) != NULL)
536: {
537: lastoffline = FALSE;
538: lastoff = 0;
539: }
540:
541: /*
542: * Save the values for when (options & SEARCH_KEEP) is used.
543: * (there is no "if ()" around this because gcc wants them initialized)
544: */
545: old_lastsdir = lastsdir;
546: old_lastoffline = lastoffline;
547: old_lastend = lastend;
548: old_lastoff = lastoff;
549:
550: pos = curwin->w_cursor; /* start searching at the cursor position */
551:
552: /*
553: * Find out the direction of the search.
554: */
555: if (dirc == 0)
556: dirc = lastsdir;
557: else
558: lastsdir = dirc;
559: if (options & SEARCH_REV)
560: {
561: #ifdef WIN32
562: /* There is a bug in the Visual C++ 2.2 compiler which means that
563: * dirc always ends up being '/' */
564: dirc = (dirc == '/') ? '?' : '/';
565: #else
566: if (dirc == '/')
567: dirc = '?';
568: else
569: dirc = '/';
570: #endif
571: }
572:
573: /*
574: * Repeat the search when pattern followed by ';', e.g. "/foo/;?bar".
575: */
576: for (;;)
577: {
578: searchstr = str;
579: dircp = NULL;
580: /* use previous pattern */
581: if (str == NULL || *str == NUL || *str == dirc)
582: {
583: if (search_pattern == NULL) /* no previous pattern */
584: {
585: emsg(e_noprevre);
586: retval = 0;
587: goto end_do_search;
588: }
589: searchstr = (char_u *)""; /* make myregcomp() use search_pattern */
590: }
591:
592: if (str != NULL && *str != NUL) /* look for (new) offset */
593: {
594: /*
595: * Find end of regular expression.
596: * If there is a matching '/' or '?', toss it.
597: */
598: p = skip_regexp(str, dirc);
599: if (*p == dirc)
600: {
601: dircp = p; /* remember where we put the NUL */
602: *p++ = NUL;
603: }
604: lastoffline = FALSE;
605: lastend = FALSE;
606: lastoff = 0;
607: /*
608: * Check for a line offset or a character offset.
609: * For get_address (echo off) we don't check for a character
610: * offset, because it is meaningless and the 's' could be a
611: * substitute command.
612: */
613: if (*p == '+' || *p == '-' || isdigit(*p))
614: lastoffline = TRUE;
615: else if ((options & SEARCH_OPT) &&
616: (*p == 'e' || *p == 's' || *p == 'b'))
617: {
618: if (*p == 'e') /* end */
619: lastend = SEARCH_END;
620: ++p;
621: }
622: if (isdigit(*p) || *p == '+' || *p == '-') /* got an offset */
623: {
624: if (isdigit(*p) || isdigit(*(p + 1)))
625: lastoff = atol((char *)p); /* 'nr' or '+nr' or '-nr' */
626: else if (*p == '-') /* single '-' */
627: lastoff = -1;
628: else /* single '+' */
629: lastoff = 1;
630: ++p;
631: while (isdigit(*p)) /* skip number */
632: ++p;
633: }
634: searchcmdlen = p - str; /* compute length of search command
635: for get_address() */
636: str = p; /* put str after search command */
637: }
638:
639: if (options & SEARCH_ECHO)
640: {
641: msg_start();
642: msg_outchar(dirc);
643: msg_outtrans(*searchstr == NUL ? search_pattern : searchstr);
644: if (lastoffline || lastend || lastoff)
645: {
646: msg_outchar(dirc);
647: if (lastend)
648: msg_outchar('e');
649: else if (!lastoffline)
650: msg_outchar('s');
651: if (lastoff < 0)
652: {
653: msg_outchar('-');
654: msg_outnum((long)-lastoff);
655: }
656: else if (lastoff > 0 || lastoffline)
657: {
658: msg_outchar('+');
659: msg_outnum((long)lastoff);
660: }
661: }
662: msg_clr_eos();
663: (void)msg_check();
664:
665: gotocmdline(FALSE);
666: flushbuf();
667: }
668:
669: /*
670: * If there is a character offset, subtract it from the current
671: * position, so we don't get stuck at "?pat?e+2" or "/pat/s-2".
672: * This is not done for a line offset, because then we would not be vi
673: * compatible.
674: */
675: if (!lastoffline && lastoff)
676: {
677: if (lastoff > 0)
678: {
679: c = lastoff;
680: while (c--)
681: if ((i = dec(&pos)) != 0)
682: break;
683: if (i == -1) /* at start of buffer */
684: goto_endofbuf(&pos);
685: }
686: else
687: {
688: c = -lastoff;
689: while (c--)
690: if ((i = inc(&pos)) != 0)
691: break;
692: if (i == -1) /* at end of buffer */
693: {
694: pos.lnum = 1;
695: pos.col = 0;
696: }
697: }
698: }
699:
700: c = searchit(&pos, dirc == '/' ? FORWARD : BACKWARD, searchstr, count,
701: lastend + (options &
702: (SEARCH_KEEP + SEARCH_HIS + SEARCH_MSG +
703: ((str != NULL && *str == ';') ? 0 : SEARCH_NOOF))),
704: 2);
705: if (dircp != NULL)
706: *dircp = dirc; /* put second '/' or '?' back for normal() */
707: if (c == FAIL)
708: {
709: retval = 0;
710: goto end_do_search;
711: }
712: if (lastend)
713: op_inclusive = TRUE; /* 'e' includes last character */
714:
715: retval = 1; /* pattern found */
716:
717: /*
718: * Add character and/or line offset
719: */
720: if (!(options & SEARCH_NOOF) || *str == ';')
721: {
722: if (lastoffline) /* Add the offset to the line number. */
723: {
724: c = pos.lnum + lastoff;
725: if (c < 1)
726: pos.lnum = 1;
727: else if (c > curbuf->b_ml.ml_line_count)
728: pos.lnum = curbuf->b_ml.ml_line_count;
729: else
730: pos.lnum = c;
731: pos.col = 0;
732:
733: retval = 2; /* pattern found, line offset added */
734: }
735: else
736: {
737: if (lastoff > 0) /* to the right, check for end of line */
738: {
739: p = ml_get_pos(&pos) + 1;
740: c = lastoff;
741: while (c-- && *p++ != NUL)
742: ++pos.col;
743: }
744: else /* to the left, check for start of line */
745: {
746: if ((c = pos.col + lastoff) < 0)
747: c = 0;
748: pos.col = c;
749: }
750: }
751: }
752:
753: /*
754: * The search command can be followed by a ';' to do another search.
755: * For example: "/pat/;/foo/+3;?bar"
756: * This is like doing another search command, except:
757: * - The remembered direction '/' or '?' is from the first search.
758: * - When an error happens the cursor isn't moved at all.
759: * Don't do this when called by get_address() (it handles ';' itself).
760: */
761: if (!(options & SEARCH_OPT) || str == NULL || *str != ';')
762: break;
763:
764: dirc = *++str;
765: if (dirc != '?' && dirc != '/')
766: {
767: retval = 0;
768: EMSG("Expected '?' or '/' after ';'");
769: goto end_do_search;
770: }
771: ++str;
772: }
773:
774: if (options & SEARCH_MARK)
775: setpcmark();
776: curwin->w_cursor = pos;
777: curwin->w_set_curswant = TRUE;
778:
779: end_do_search:
780: if (options & SEARCH_KEEP)
781: {
782: lastsdir = old_lastsdir;
783: lastoffline = old_lastoffline;
784: lastend = old_lastend;
785: lastoff = old_lastoff;
786: }
787: return retval;
788: }
789:
790: /*
791: * search_for_exact_line(pos, dir, pat)
792: *
793: * Search for a line starting with the given pattern (ignoring leading
794: * white-space), starting from pos and going in direction dir. pos will
795: * contain the position of the match found. Blank lines will never match.
796: * Return OK for success, or FAIL if no line found.
797: */
798: int
799: search_for_exact_line(pos, dir, pat)
800: FPOS *pos;
801: int dir;
802: char_u *pat;
803: {
804: linenr_t start = 0;
805: char_u *ptr;
806: char_u *p;
807:
808: if (curbuf->b_ml.ml_line_count == 0)
809: return FAIL;
810: for (;;)
811: {
812: pos->lnum += dir;
813: if (pos->lnum < 1)
814: {
815: if (p_ws)
816: {
817: pos->lnum = curbuf->b_ml.ml_line_count;
818: if (!shortmess(SHM_SEARCH))
819: give_warning(top_bot_msg);
820: }
821: else
822: {
823: pos->lnum = 1;
824: break;
825: }
826: }
827: else if (pos->lnum > curbuf->b_ml.ml_line_count)
828: {
829: if (p_ws)
830: {
831: pos->lnum = 1;
832: if (!shortmess(SHM_SEARCH))
833: give_warning(bot_top_msg);
834: }
835: else
836: {
837: pos->lnum = 1;
838: break;
839: }
840: }
841: if (pos->lnum == start)
842: break;
843: if (start == 0)
844: start = pos->lnum;
845: ptr = ml_get(pos->lnum);
846: p = skipwhite(ptr);
847: pos->col = p - ptr;
848: if (*p != NUL && STRNCMP(p, pat, STRLEN(pat)) == 0)
849: return OK;
850: else if (*p != NUL && p_ic)
851: {
852: ptr = pat;
853: while (*p && TO_LOWER(*p) == TO_LOWER(*ptr))
854: {
855: ++p;
856: ++ptr;
857: }
858: if (*ptr == NUL)
859: return OK;
860: }
861: }
862: return FAIL;
863: }
864:
865: /*
866: * Character Searches
867: */
868:
869: /*
870: * searchc(c, dir, type, count)
871: *
872: * Search for character 'c', in direction 'dir'. If 'type' is 0, move to the
873: * position of the character, otherwise move to just before the char.
874: * Repeat this 'count' times.
875: */
876: int
877: searchc(c, dir, type, count)
878: int c;
879: register int dir;
880: int type;
881: long count;
882: {
883: static int lastc = NUL; /* last character searched for */
884: static int lastcdir; /* last direction of character search */
885: static int lastctype; /* last type of search ("find" or "to") */
886: register int col;
887: char_u *p;
888: int len;
889:
890: if (c != NUL) /* normal search: remember args for repeat */
891: {
892: if (!KeyStuffed) /* don't remember when redoing */
893: {
894: lastc = c;
895: lastcdir = dir;
896: lastctype = type;
897: }
898: }
899: else /* repeat previous search */
900: {
901: if (lastc == NUL)
902: return FALSE;
903: if (dir) /* repeat in opposite direction */
904: dir = -lastcdir;
905: else
906: dir = lastcdir;
907: type = lastctype;
908: c = lastc;
909: }
910:
911: p = ml_get_curline();
912: col = curwin->w_cursor.col;
913: len = STRLEN(p);
914:
915: while (count--)
916: {
917: for (;;)
918: {
919: if ((col += dir) < 0 || col >= len)
920: return FALSE;
921: if (p[col] == c)
922: break;
923: }
924: }
925: if (type)
926: col -= dir;
927: curwin->w_cursor.col = col;
928: return TRUE;
929: }
930:
931: /*
932: * "Other" Searches
933: */
934:
935: /*
936: * findmatch - find the matching paren or brace
937: *
938: * Improvement over vi: Braces inside quotes are ignored.
939: */
940: FPOS *
941: findmatch(initc)
942: int initc;
943: {
944: return findmatchlimit(initc, 0, 0);
945: }
946:
947: /*
948: * findmatchlimit -- find the matching paren or brace, if it exists within
949: * maxtravel lines of here. A maxtravel of 0 means search until you fall off
950: * the edge of the file.
951: *
952: * flags: FM_BACKWARD search backwards (when initc is '/', '*' or '#')
953: * FM_FORWARD search forwards (when initc is '/', '*' or '#')
954: * FM_BLOCKSTOP stop at start/end of block ({ or } in column 0)
955: * FM_SKIPCOMM skip comments (not implemented yet!)
956: */
957:
958: FPOS *
959: findmatchlimit(initc, flags, maxtravel)
960: int initc;
961: int flags;
962: int maxtravel;
963: {
964: static FPOS pos; /* current search position */
965: int findc; /* matching brace */
966: int c;
967: int count = 0; /* cumulative number of braces */
968: int idx = 0; /* init for gcc */
969: static char_u table[6] = {'(', ')', '[', ']', '{', '}'};
970: #ifdef RIGHTLEFT
971: static char_u table_rl[6] = {')', '(', ']', '[', '}', '{'};
972: #endif
973: int inquote = FALSE; /* TRUE when inside quotes */
974: register char_u *linep; /* pointer to current line */
975: char_u *ptr;
976: int do_quotes; /* check for quotes in current line */
977: int at_start; /* do_quotes value at start position */
978: int hash_dir = 0; /* Direction searched for # things */
979: int comment_dir = 0; /* Direction searched for comments */
980: FPOS match_pos; /* Where last slash-star was found */
981: int start_in_quotes; /* start position is in quotes */
982: int traveled = 0; /* how far we've searched so far */
983: int ignore_cend = FALSE; /* ignore comment end */
984: int cpo_match; /* vi compatible matching */
985: int dir; /* Direction to search */
986:
987: pos = curwin->w_cursor;
988: linep = ml_get(pos.lnum);
989:
990: cpo_match = (vim_strchr(p_cpo, CPO_MATCH) != NULL);
991:
992: /* Direction to search when initc is '/', '*' or '#' */
993: if (flags & FM_BACKWARD)
994: dir = BACKWARD;
995: else if (flags & FM_FORWARD)
996: dir = FORWARD;
997: else
998: dir = 0;
999:
1000: /*
1001: * if initc given, look in the table for the matching character
1002: * '/' and '*' are special cases: look for start or end of comment.
1003: * When '/' is used, we ignore running backwards into an star-slash, for
1004: * "[*" command, we just want to find any comment.
1005: */
1006: if (initc == '/' || initc == '*')
1007: {
1008: comment_dir = dir;
1009: if (initc == '/')
1010: ignore_cend = TRUE;
1011: idx = (dir == FORWARD) ? 0 : 1;
1012: initc = NUL;
1013: }
1014: else if (initc != '#' && initc != NUL)
1015: {
1016: for (idx = 0; idx < 6; ++idx)
1017: #ifdef RIGHTLEFT
1018: if ((curwin->w_p_rl ? table_rl : table)[idx] == initc)
1019: {
1020: initc = (curwin->w_p_rl ? table_rl : table)[idx = idx ^ 1];
1021:
1022: #else
1023: if (table[idx] == initc)
1024: {
1025: initc = table[idx = idx ^ 1];
1026: #endif
1027: break;
1028: }
1029: if (idx == 6) /* invalid initc! */
1030: return NULL;
1031: }
1032: /*
1033: * Either initc is '#', or no initc was given and we need to look under the
1034: * cursor.
1035: */
1036: else
1037: {
1038: if (initc == '#')
1039: {
1040: hash_dir = dir;
1041: }
1042: else
1043: {
1044: /*
1045: * initc was not given, must look for something to match under
1046: * or near the cursor.
1047: */
1048: if (linep[0] == '#' && pos.col == 0)
1049: {
1050: /* If it's not #if, #else etc, we should look for a brace
1051: * instead */
1052: for (c = 1; vim_iswhite(linep[c]); c++)
1053: ;
1054: if (STRNCMP(linep + c, "if", (size_t)2) == 0 ||
1055: STRNCMP(linep + c, "endif", (size_t)5) == 0 ||
1056: STRNCMP(linep + c, "el", (size_t)2) == 0)
1057: hash_dir = 1;
1058: }
1059:
1060: /*
1061: * Are we on a comment?
1062: */
1063: else if (linep[pos.col] == '/')
1064: {
1065: if (linep[pos.col + 1] == '*')
1066: {
1067: comment_dir = 1;
1068: idx = 0;
1069: pos.col++;
1070: }
1071: else if (pos.col > 0 && linep[pos.col - 1] == '*')
1072: {
1073: comment_dir = -1;
1074: idx = 1;
1075: pos.col--;
1076: }
1077: }
1078: else if (linep[pos.col] == '*')
1079: {
1080: if (linep[pos.col + 1] == '/')
1081: {
1082: comment_dir = -1;
1083: idx = 1;
1084: }
1085: else if (pos.col > 0 && linep[pos.col - 1] == '/')
1086: {
1087: comment_dir = 1;
1088: idx = 0;
1089: }
1090: }
1091:
1092: /*
1093: * If we are not on a comment or the # at the start of a line, then
1094: * look for brace anywhere on this line after the cursor.
1095: */
1096: if (!hash_dir && !comment_dir)
1097: {
1098: /*
1099: * find the brace under or after the cursor
1100: */
1101: linep = ml_get(pos.lnum);
1102: idx = 6; /* error if this line is empty */
1103: for (;;)
1104: {
1105: initc = linep[pos.col];
1106: if (initc == NUL)
1107: break;
1108:
1109: for (idx = 0; idx < 6; ++idx)
1110: #ifdef RIGHTLEFT
1111: if ((curwin->w_p_rl ? table_rl : table)[idx] == initc)
1112: #else
1113: if (table[idx] == initc)
1114: #endif
1115: break;
1116: if (idx != 6)
1117: break;
1118: ++pos.col;
1119: }
1120: if (idx == 6)
1121: {
1122: if (linep[0] == '#')
1123: hash_dir = 1;
1124: else
1125: return NULL;
1126: }
1127: }
1128: }
1129: if (hash_dir)
1130: {
1131: /*
1132: * Look for matching #if, #else, #elif, or #endif
1133: */
1134: op_motion_type = MLINE; /* Linewise for this case only */
1135: if (initc != '#')
1136: {
1137: ptr = skipwhite(linep + 1);
1138: if (STRNCMP(ptr, "if", (size_t)2) == 0 ||
1139: STRNCMP(ptr, "el", (size_t)2) == 0)
1140: hash_dir = 1;
1141: else if (STRNCMP(ptr, "endif", (size_t)5) == 0)
1142: hash_dir = -1;
1143: else
1144: return NULL;
1145: }
1146: pos.col = 0;
1147: while (!got_int)
1148: {
1149: if (hash_dir > 0)
1150: {
1151: if (pos.lnum == curbuf->b_ml.ml_line_count)
1152: break;
1153: }
1154: else if (pos.lnum == 1)
1155: break;
1156: pos.lnum += hash_dir;
1157: linep = ml_get(pos.lnum);
1158: line_breakcheck();
1159: if (linep[0] != '#')
1160: continue;
1161: ptr = linep + 1;
1162: while (*ptr == ' ' || *ptr == TAB)
1163: ptr++;
1164: if (hash_dir > 0)
1165: {
1166: if (STRNCMP(ptr, "if", (size_t)2) == 0)
1167: count++;
1168: else if (STRNCMP(ptr, "el", (size_t)2) == 0)
1169: {
1170: if (count == 0)
1171: return &pos;
1172: }
1173: else if (STRNCMP(ptr, "endif", (size_t)5) == 0)
1174: {
1175: if (count == 0)
1176: return &pos;
1177: count--;
1178: }
1179: }
1180: else
1181: {
1182: if (STRNCMP(ptr, "if", (size_t)2) == 0)
1183: {
1184: if (count == 0)
1185: return &pos;
1186: count--;
1187: }
1188: else if (initc == '#' && STRNCMP(ptr, "el", (size_t)2) == 0)
1189: {
1190: if (count == 0)
1191: return &pos;
1192: }
1193: else if (STRNCMP(ptr, "endif", (size_t)5) == 0)
1194: count++;
1195: }
1196: }
1197: return NULL;
1198: }
1199: }
1200:
1201: #ifdef RIGHTLEFT
1202: findc = (curwin->w_p_rl ? table_rl : table)[idx ^ 1];
1203: #else
1204: findc = table[idx ^ 1]; /* get matching brace */
1205: #endif
1206: idx &= 1;
1207:
1208: do_quotes = -1;
1209: start_in_quotes = MAYBE;
1210: while (!got_int)
1211: {
1212: /*
1213: * Go to the next position, forward or backward. We could use
1214: * inc() and dec() here, but that is much slower
1215: */
1216: if (idx) /* backward search */
1217: {
1218: if (pos.col == 0) /* at start of line, go to prev. one */
1219: {
1220: if (pos.lnum == 1) /* start of file */
1221: break;
1222: --pos.lnum;
1223:
1224: if (maxtravel && traveled++ > maxtravel)
1225: break;
1226:
1227: linep = ml_get(pos.lnum);
1228: pos.col = STRLEN(linep); /* put pos.col on trailing NUL */
1229: do_quotes = -1;
1230: line_breakcheck();
1231: }
1232: else
1233: --pos.col;
1234: }
1235: else /* forward search */
1236: {
1237: if (linep[pos.col] == NUL) /* at end of line, go to next one */
1238: {
1239: if (pos.lnum == curbuf->b_ml.ml_line_count) /* end of file */
1240: break;
1241: ++pos.lnum;
1242:
1243: if (maxtravel && traveled++ > maxtravel)
1244: break;
1245:
1246: linep = ml_get(pos.lnum);
1247: pos.col = 0;
1248: do_quotes = -1;
1249: line_breakcheck();
1250: }
1251: else
1252: ++pos.col;
1253: }
1254:
1255: /*
1256: * If FM_BLOCKSTOP given, stop at a '{' or '}' in column 0.
1257: */
1258: if (pos.col == 0 && (flags & FM_BLOCKSTOP) &&
1259: (linep[0] == '{' || linep[0] == '}'))
1260: {
1261: if (linep[0] == findc && count == 0) /* match! */
1262: return &pos;
1263: break; /* out of scope */
1264: }
1265:
1266: if (comment_dir)
1267: {
1268: /* Note: comments do not nest, and we ignore quotes in them */
1269: if (comment_dir == 1)
1270: {
1271: if (linep[pos.col] == '*' && linep[pos.col + 1] == '/')
1272: {
1273: pos.col++;
1274: return &pos;
1275: }
1276: }
1277: else /* Searching backwards */
1278: {
1279: /*
1280: * A comment may contain slash-star, it may also start or end
1281: * with slash-star-slash. I'm not using real examples though
1282: * because "gcc -Wall" would complain -- webb
1283: */
1284: if (pos.col == 0)
1285: continue;
1286: else if (linep[pos.col - 1] == '/' && linep[pos.col] == '*')
1287: {
1288: count++;
1289: match_pos = pos;
1290: match_pos.col--;
1291: }
1292: else if (linep[pos.col - 1] == '*' && linep[pos.col] == '/')
1293: {
1294: if (count > 0)
1295: pos = match_pos;
1296: else if (pos.col > 1 && linep[pos.col - 2] == '/')
1297: pos.col -= 2;
1298: else if (ignore_cend)
1299: continue;
1300: else
1301: return NULL;
1302: return &pos;
1303: }
1304: }
1305: continue;
1306: }
1307:
1308: /*
1309: * If smart matching ('cpoptions' does not contain '%'), braces inside
1310: * of quotes are ignored, but only if there is an even number of
1311: * quotes in the line.
1312: */
1313: if (cpo_match)
1314: do_quotes = 0;
1315: else if (do_quotes == -1)
1316: {
1317: /*
1318: * count the number of quotes in the line, skipping \" and '"'
1319: */
1320: at_start = do_quotes;
1321: for (ptr = linep; *ptr; ++ptr)
1322: {
1323: if (ptr == linep + curwin->w_cursor.col)
1324: at_start = (do_quotes & 1);
1325: if (*ptr == '"' && (ptr == linep || ptr[-1] != '\\') &&
1326: (ptr == linep || ptr[-1] != '\'' || ptr[1] != '\''))
1327: ++do_quotes;
1328: }
1329: do_quotes &= 1; /* result is 1 with even number of quotes */
1330:
1331: /*
1332: * If we find an uneven count, check current line and previous
1333: * one for a '\' at the end.
1334: */
1335: if (!do_quotes)
1336: {
1337: inquote = FALSE;
1338: if (ptr[-1] == '\\')
1339: {
1340: do_quotes = 1;
1341: if (start_in_quotes == MAYBE)
1342: {
1343: inquote = !at_start;
1344: if (inquote)
1345: start_in_quotes = TRUE;
1346: }
1347: else if (idx) /* backward search */
1348: inquote = TRUE;
1349: }
1350: if (pos.lnum > 1)
1351: {
1352: ptr = ml_get(pos.lnum - 1);
1353: if (*ptr && *(ptr + STRLEN(ptr) - 1) == '\\')
1354: {
1355: do_quotes = 1;
1356: if (start_in_quotes == MAYBE)
1357: {
1358: inquote = at_start;
1359: if (inquote)
1360: start_in_quotes = TRUE;
1361: }
1362: else if (!idx) /* forward search */
1363: inquote = TRUE;
1364: }
1365: }
1366: }
1367: }
1368: if (start_in_quotes == MAYBE)
1369: start_in_quotes = FALSE;
1370:
1371: /*
1372: * If 'smartmatch' is set:
1373: * Things inside quotes are ignored by setting 'inquote'. If we
1374: * find a quote without a preceding '\' invert 'inquote'. At the
1375: * end of a line not ending in '\' we reset 'inquote'.
1376: *
1377: * In lines with an uneven number of quotes (without preceding '\')
1378: * we do not know which part to ignore. Therefore we only set
1379: * inquote if the number of quotes in a line is even, unless this
1380: * line or the previous one ends in a '\'. Complicated, isn't it?
1381: */
1382: switch (c = linep[pos.col])
1383: {
1384: case NUL:
1385: /* at end of line without trailing backslash, reset inquote */
1386: if (pos.col == 0 || linep[pos.col - 1] != '\\')
1387: {
1388: inquote = FALSE;
1389: start_in_quotes = FALSE;
1390: }
1391: break;
1392:
1393: case '"':
1394: /* a quote that is preceded with a backslash is ignored */
1395: if (do_quotes && (pos.col == 0 || linep[pos.col - 1] != '\\'))
1396: {
1397: inquote = !inquote;
1398: start_in_quotes = FALSE;
1399: }
1400: break;
1401:
1402: /*
1403: * If smart matching ('cpoptions' does not contain '%'):
1404: * Skip things in single quotes: 'x' or '\x'. Be careful for single
1405: * single quotes, eg jon's. Things like '\233' or '\x3f' are not
1406: * skipped, there is never a brace in them.
1407: */
1408: case '\'':
1409: if (vim_strchr(p_cpo, CPO_MATCH) == NULL)
1410: {
1411: if (idx) /* backward search */
1412: {
1413: if (pos.col > 1)
1414: {
1415: if (linep[pos.col - 2] == '\'')
1416: pos.col -= 2;
1417: else if (linep[pos.col - 2] == '\\' &&
1418: pos.col > 2 && linep[pos.col - 3] == '\'')
1419: pos.col -= 3;
1420: }
1421: }
1422: else if (linep[pos.col + 1]) /* forward search */
1423: {
1424: if (linep[pos.col + 1] == '\\' &&
1425: linep[pos.col + 2] && linep[pos.col + 3] == '\'')
1426: pos.col += 3;
1427: else if (linep[pos.col + 2] == '\'')
1428: pos.col += 2;
1429: }
1430: }
1431: break;
1432:
1433: default:
1434: /* Check for match outside of quotes, and inside of
1435: * quotes when the start is also inside of quotes */
1436: if (!inquote || start_in_quotes == TRUE)
1437: {
1438: if (c == initc)
1439: count++;
1440: else if (c == findc)
1441: {
1442: if (count == 0)
1443: return &pos;
1444: count--;
1445: }
1446: }
1447: }
1448: }
1449:
1450: if (comment_dir == -1 && count > 0)
1451: {
1452: pos = match_pos;
1453: return &pos;
1454: }
1455: return (FPOS *) NULL; /* never found it */
1456: }
1457:
1458: /*
1459: * Move cursor briefly to character matching the one under the cursor.
1460: * Show the match only if it is visible on the screen.
1461: */
1462: void
1463: showmatch()
1464: {
1465: FPOS *lpos, csave;
1466: colnr_t vcol;
1467:
1468: if ((lpos = findmatch(NUL)) == NULL) /* no match, so beep */
1469: beep_flush();
1470: else if (lpos->lnum >= curwin->w_topline)
1471: {
1472: if (!curwin->w_p_wrap)
1473: getvcol(curwin, lpos, NULL, &vcol, NULL);
1474: if (curwin->w_p_wrap || (vcol >= curwin->w_leftcol &&
1475: vcol < curwin->w_leftcol + Columns))
1476: {
1477: updateScreen(VALID_TO_CURSCHAR); /* show the new char first */
1478: csave = curwin->w_cursor;
1479: curwin->w_cursor = *lpos; /* move to matching char */
1480: cursupdate();
1481: showruler(0);
1482: setcursor();
1483: cursor_on(); /* make sure that the cursor is shown */
1484: flushbuf();
1485:
1486: /*
1487: * brief pause, unless 'm' is present in 'cpo' and a character is
1488: * available.
1489: */
1490: if (vim_strchr(p_cpo, CPO_SHOWMATCH) != NULL)
1491: mch_delay(500L, TRUE);
1492: else if (!char_avail())
1493: mch_delay(500L, FALSE);
1494: curwin->w_cursor = csave; /* restore cursor position */
1495: cursupdate();
1496: }
1497: }
1498: }
1499:
1500: /*
1501: * findsent(dir, count) - Find the start of the next sentence in direction
1502: * 'dir' Sentences are supposed to end in ".", "!" or "?" followed by white
1503: * space or a line break. Also stop at an empty line.
1504: * Return OK if the next sentence was found.
1505: */
1506: int
1507: findsent(dir, count)
1508: int dir;
1509: long count;
1510: {
1511: FPOS pos, tpos;
1512: register int c;
1513: int (*func) __PARMS((FPOS *));
1514: int startlnum;
1515: int noskip = FALSE; /* do not skip blanks */
1516:
1517: pos = curwin->w_cursor;
1518: if (dir == FORWARD)
1519: func = incl;
1520: else
1521: func = decl;
1522:
1523: while (count--)
1524: {
1525: /*
1526: * if on an empty line, skip upto a non-empty line
1527: */
1528: if (gchar(&pos) == NUL)
1529: {
1530: do
1531: if ((*func)(&pos) == -1)
1532: break;
1533: while (gchar(&pos) == NUL);
1534: if (dir == FORWARD)
1535: goto found;
1536: }
1537: /*
1538: * if on the start of a paragraph or a section and searching forward,
1539: * go to the next line
1540: */
1541: else if (dir == FORWARD && pos.col == 0 &&
1542: startPS(pos.lnum, NUL, FALSE))
1543: {
1544: if (pos.lnum == curbuf->b_ml.ml_line_count)
1545: return FAIL;
1546: ++pos.lnum;
1547: goto found;
1548: }
1549: else if (dir == BACKWARD)
1550: decl(&pos);
1551:
1552: /* go back to the previous non-blank char */
1553: while ((c = gchar(&pos)) == ' ' || c == '\t' ||
1554: (dir == BACKWARD && vim_strchr((char_u *)".!?)]\"'", c) != NULL))
1555: {
1556: if (decl(&pos) == -1)
1557: break;
1558: /* when going forward: Stop in front of empty line */
1559: if (lineempty(pos.lnum) && dir == FORWARD)
1560: {
1561: incl(&pos);
1562: goto found;
1563: }
1564: }
1565:
1566: /* remember the line where the search started */
1567: startlnum = pos.lnum;
1568:
1569: for (;;) /* find end of sentence */
1570: {
1571: c = gchar(&pos);
1572: if (c == NUL || (pos.col == 0 && startPS(pos.lnum, NUL, FALSE)))
1573: {
1574: if (dir == BACKWARD && pos.lnum != startlnum)
1575: ++pos.lnum;
1576: break;
1577: }
1578: if (c == '.' || c == '!' || c == '?')
1579: {
1580: tpos = pos;
1581: do
1582: if ((c = inc(&tpos)) == -1)
1583: break;
1584: while (vim_strchr((char_u *)")]\"'", c = gchar(&tpos)) != NULL);
1585: if (c == -1 || c == ' ' || c == '\t' || c == NUL)
1586: {
1587: pos = tpos;
1588: if (gchar(&pos) == NUL) /* skip NUL at EOL */
1589: inc(&pos);
1590: break;
1591: }
1592: }
1593: if ((*func)(&pos) == -1)
1594: {
1595: if (count)
1596: return FAIL;
1597: noskip = TRUE;
1598: break;
1599: }
1600: }
1601: found:
1602: /* skip white space */
1603: while (!noskip && ((c = gchar(&pos)) == ' ' || c == '\t'))
1604: if (incl(&pos) == -1)
1605: break;
1606: }
1607:
1608: setpcmark();
1609: curwin->w_cursor = pos;
1610: return OK;
1611: }
1612:
1613: /*
1614: * findpar(dir, count, what) - Find the next paragraph in direction 'dir'
1615: * Paragraphs are currently supposed to be separated by empty lines.
1616: * Return TRUE if the next paragraph was found.
1617: * If 'what' is '{' or '}' we go to the next section.
1618: * If 'both' is TRUE also stop at '}'.
1619: */
1620: int
1621: findpar(dir, count, what, both)
1622: register int dir;
1623: long count;
1624: int what;
1625: int both;
1626: {
1627: register linenr_t curr;
1628: int did_skip; /* TRUE after separating lines have
1629: been skipped */
1630: int first; /* TRUE on first line */
1631:
1632: curr = curwin->w_cursor.lnum;
1633:
1634: while (count--)
1635: {
1636: did_skip = FALSE;
1637: for (first = TRUE; ; first = FALSE)
1638: {
1639: if (*ml_get(curr) != NUL)
1640: did_skip = TRUE;
1641:
1642: if (!first && did_skip && startPS(curr, what, both))
1643: break;
1644:
1645: if ((curr += dir) < 1 || curr > curbuf->b_ml.ml_line_count)
1646: {
1647: if (count)
1648: return FALSE;
1649: curr -= dir;
1650: break;
1651: }
1652: }
1653: }
1654: setpcmark();
1655: if (both && *ml_get(curr) == '}') /* include line with '}' */
1656: ++curr;
1657: curwin->w_cursor.lnum = curr;
1658: if (curr == curbuf->b_ml.ml_line_count)
1659: {
1660: if ((curwin->w_cursor.col = STRLEN(ml_get(curr))) != 0)
1661: {
1662: --curwin->w_cursor.col;
1663: op_inclusive = TRUE;
1664: }
1665: }
1666: else
1667: curwin->w_cursor.col = 0;
1668: return TRUE;
1669: }
1670:
1671: /*
1672: * check if the string 's' is a nroff macro that is in option 'opt'
1673: */
1674: static int
1675: inmacro(opt, s)
1676: char_u *opt;
1677: register char_u *s;
1678: {
1679: register char_u *macro;
1680:
1681: for (macro = opt; macro[0]; ++macro)
1682: {
1683: if (macro[0] == s[0] && (((s[1] == NUL || s[1] == ' ') &&
1684: (macro[1] == NUL || macro[1] == ' ')) || macro[1] == s[1]))
1685: break;
1686: ++macro;
1687: if (macro[0] == NUL)
1688: break;
1689: }
1690: return (macro[0] != NUL);
1691: }
1692:
1693: /*
1694: * startPS: return TRUE if line 'lnum' is the start of a section or paragraph.
1695: * If 'para' is '{' or '}' only check for sections.
1696: * If 'both' is TRUE also stop at '}'
1697: */
1698: int
1699: startPS(lnum, para, both)
1700: linenr_t lnum;
1701: int para;
1702: int both;
1703: {
1704: register char_u *s;
1705:
1706: s = ml_get(lnum);
1707: if (*s == para || *s == '\f' || (both && *s == '}'))
1708: return TRUE;
1709: if (*s == '.' && (inmacro(p_sections, s + 1) ||
1710: (!para && inmacro(p_para, s + 1))))
1711: return TRUE;
1712: return FALSE;
1713: }
1714:
1715: /*
1716: * The following routines do the word searches performed by the 'w', 'W',
1717: * 'b', 'B', 'e', and 'E' commands.
1718: */
1719:
1720: /*
1721: * To perform these searches, characters are placed into one of three
1722: * classes, and transitions between classes determine word boundaries.
1723: *
1724: * The classes are:
1725: *
1726: * 0 - white space
1727: * 1 - keyword charactes (letters, digits and underscore)
1728: * 2 - everything else
1729: */
1730:
1731: static int stype; /* type of the word motion being performed */
1732:
1733: /*
1734: * cls() - returns the class of character at curwin->w_cursor
1735: *
1736: * The 'type' of the current search modifies the classes of characters if a
1737: * 'W', 'B', or 'E' motion is being done. In this case, chars. from class 2
1738: * are reported as class 1 since only white space boundaries are of interest.
1739: */
1740: static int
1741: cls()
1742: {
1743: register int c;
1744:
1745: c = gchar_cursor();
1746: if (c == ' ' || c == '\t' || c == NUL)
1747: return 0;
1748:
1749: if (iswordchar(c))
1750: return 1;
1751:
1752: /*
1753: * If stype is non-zero, report these as class 1.
1754: */
1755: return (stype == 0) ? 2 : 1;
1756: }
1757:
1758:
1759: /*
1760: * fwd_word(count, type, eol) - move forward one word
1761: *
1762: * Returns FAIL if the cursor was already at the end of the file.
1763: * If eol is TRUE, last word stops at end of line (for operators).
1764: */
1765: int
1766: fwd_word(count, type, eol)
1767: long count;
1768: int type;
1769: int eol;
1770: {
1771: int sclass; /* starting class */
1772: int i;
1773: int last_line;
1774:
1775: stype = type;
1776: while (--count >= 0)
1777: {
1778: sclass = cls();
1779:
1780: /*
1781: * We always move at least one character, unless on the last character
1782: * in the buffer.
1783: */
1784: last_line = (curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count);
1785: i = inc_cursor();
1786: if (i == -1 || (i == 1 && last_line))
1787: /* started at last char in file */
1788: return FAIL;
1789: if (i == 1 && eol && count == 0) /* started at last char in line */
1790: return OK;
1791:
1792: /*
1793: * Go one char past end of current word (if any)
1794: */
1795: if (sclass != 0)
1796: while (cls() == sclass)
1797: {
1798: i = inc_cursor();
1799: if (i == -1 || (i == 1 && eol && count == 0))
1800: return OK;
1801: }
1802:
1803: /*
1804: * go to next non-white
1805: */
1806: while (cls() == 0)
1807: {
1808: /*
1809: * We'll stop if we land on a blank line
1810: */
1811: if (curwin->w_cursor.col == 0 && *ml_get_curline() == NUL)
1812: break;
1813:
1814: i = inc_cursor();
1815: if (i == -1 || (i == 1 && eol && count == 0))
1816: return OK;
1817: }
1818: }
1819: return OK;
1820: }
1821:
1822: /*
1823: * bck_word() - move backward 'count' words
1824: *
1825: * If stop is TRUE and we are already on the start of a word, move one less.
1826: *
1827: * Returns FAIL if top of the file was reached.
1828: */
1829: int
1830: bck_word(count, type, stop)
1831: long count;
1832: int type;
1833: int stop;
1834: {
1835: int sclass; /* starting class */
1836:
1837: stype = type;
1838: while (--count >= 0)
1839: {
1840: sclass = cls();
1841: if (dec_cursor() == -1) /* started at start of file */
1842: return FAIL;
1843:
1844: if (!stop || sclass == cls() || sclass == 0)
1845: {
1846: /*
1847: * Skip white space before the word.
1848: * Stop on an empty line.
1849: */
1850: while (cls() == 0)
1851: {
1852: if (curwin->w_cursor.col == 0 &&
1853: lineempty(curwin->w_cursor.lnum))
1854: goto finished;
1855:
1856: if (dec_cursor() == -1) /* hit start of file, stop here */
1857: return OK;
1858: }
1859:
1860: /*
1861: * Move backward to start of this word.
1862: */
1863: if (skip_chars(cls(), BACKWARD))
1864: return OK;
1865: }
1866:
1867: inc_cursor(); /* overshot - forward one */
1868: finished:
1869: stop = FALSE;
1870: }
1871: return OK;
1872: }
1873:
1874: /*
1875: * end_word() - move to the end of the word
1876: *
1877: * There is an apparent bug in the 'e' motion of the real vi. At least on the
1878: * System V Release 3 version for the 80386. Unlike 'b' and 'w', the 'e'
1879: * motion crosses blank lines. When the real vi crosses a blank line in an
1880: * 'e' motion, the cursor is placed on the FIRST character of the next
1881: * non-blank line. The 'E' command, however, works correctly. Since this
1882: * appears to be a bug, I have not duplicated it here.
1883: *
1884: * Returns FAIL if end of the file was reached.
1885: *
1886: * If stop is TRUE and we are already on the end of a word, move one less.
1887: * If empty is TRUE stop on an empty line.
1888: */
1889: int
1890: end_word(count, type, stop, empty)
1891: long count;
1892: int type;
1893: int stop;
1894: int empty;
1895: {
1896: int sclass; /* starting class */
1897:
1898: stype = type;
1899: while (--count >= 0)
1900: {
1901: sclass = cls();
1902: if (inc_cursor() == -1)
1903: return FAIL;
1904:
1905: /*
1906: * If we're in the middle of a word, we just have to move to the end
1907: * of it.
1908: */
1909: if (cls() == sclass && sclass != 0)
1910: {
1911: /*
1912: * Move forward to end of the current word
1913: */
1914: if (skip_chars(sclass, FORWARD))
1915: return FAIL;
1916: }
1917: else if (!stop || sclass == 0)
1918: {
1919: /*
1920: * We were at the end of a word. Go to the end of the next word.
1921: * First skip white space, if 'empty' is TRUE, stop at empty line.
1922: */
1923: while (cls() == 0)
1924: {
1925: if (empty && curwin->w_cursor.col == 0 &&
1926: lineempty(curwin->w_cursor.lnum))
1927: goto finished;
1928: if (inc_cursor() == -1) /* hit end of file, stop here */
1929: return FAIL;
1930: }
1931:
1932: /*
1933: * Move forward to the end of this word.
1934: */
1935: if (skip_chars(cls(), FORWARD))
1936: return FAIL;
1937: }
1938: dec_cursor(); /* overshot - one char backward */
1939: finished:
1940: stop = FALSE; /* we move only one word less */
1941: }
1942: return OK;
1943: }
1944:
1945: /*
1946: * bckend_word(count, type) - move back to the end of the word
1947: *
1948: * If 'eol' is TRUE, stop at end of line.
1949: *
1950: * Returns FAIL if start of the file was reached.
1951: */
1952: int
1953: bckend_word(count, type, eol)
1954: long count;
1955: int type;
1956: int eol;
1957: {
1958: int sclass; /* starting class */
1959: int i;
1960:
1961: stype = type;
1962: while (--count >= 0)
1963: {
1964: sclass = cls();
1965: if ((i = dec_cursor()) == -1)
1966: return FAIL;
1967: if (eol && i == 1)
1968: return OK;
1969:
1970: /*
1971: * Move backward to before the start of this word.
1972: */
1973: if (sclass != 0)
1974: {
1975: while (cls() == sclass)
1976: if ((i = dec_cursor()) == -1 || (eol && i == 1))
1977: return OK;
1978: }
1979:
1980: /*
1981: * Move backward to end of the previous word
1982: */
1983: while (cls() == 0)
1984: {
1985: if (curwin->w_cursor.col == 0 && lineempty(curwin->w_cursor.lnum))
1986: break;
1987: if ((i = dec_cursor()) == -1 || (eol && i == 1))
1988: return OK;
1989: }
1990: }
1991: return OK;
1992: }
1993:
1994: static int
1995: skip_chars(cclass, dir)
1996: int cclass;
1997: int dir;
1998: {
1999: while (cls() == cclass)
2000: if ((dir == FORWARD ? inc_cursor() : dec_cursor()) == -1)
2001: return TRUE;
2002: return FALSE;
2003: }
2004:
2005: /*
2006: * Go back to the start of the word or the start of white space
2007: */
2008: static void
2009: back_in_line()
2010: {
2011: int sclass; /* starting class */
2012:
2013: sclass = cls();
2014: for (;;)
2015: {
2016: if (curwin->w_cursor.col == 0) /* stop at start of line */
2017: break;
2018: --curwin->w_cursor.col;
2019: if (cls() != sclass) /* stop at start of word */
2020: {
2021: ++curwin->w_cursor.col;
2022: break;
2023: }
2024: }
2025: }
2026:
2027: /*
2028: * Find word under cursor, cursor at end
2029: */
2030: int
2031: current_word(count, type)
2032: long count;
2033: int type;
2034: {
2035: FPOS start;
2036: FPOS pos;
2037: int inclusive = TRUE;
2038:
2039: stype = type;
2040:
2041: /*
2042: * When visual area is bigger than one character: Extend it.
2043: */
2044: if (VIsual_active && !equal(curwin->w_cursor, VIsual))
2045: {
2046: if (lt(curwin->w_cursor, VIsual))
2047: {
2048: if (decl(&curwin->w_cursor) == -1)
2049: return FAIL;
2050: if (cls() == 0)
2051: {
2052: if (bckend_word(count, type, TRUE) == FAIL)
2053: return FAIL;
2054: (void)incl(&curwin->w_cursor);
2055: }
2056: else
2057: {
2058: if (bck_word(count, type, TRUE) == FAIL)
2059: return FAIL;
2060: }
2061: }
2062: else
2063: {
2064: if (incl(&curwin->w_cursor) == -1)
2065: return FAIL;
2066: if (cls() == 0)
2067: {
2068: if (fwd_word(count, type, TRUE) == FAIL)
2069: return FAIL;
2070: (void)oneleft();
2071: }
2072: else
2073: {
2074: if (end_word(count, type, TRUE, TRUE) == FAIL)
2075: return FAIL;
2076: }
2077: }
2078: return OK;
2079: }
2080:
2081: /*
2082: * Go to start of current word or white space.
2083: */
2084: back_in_line();
2085: start = curwin->w_cursor;
2086:
2087: /*
2088: * If the start is on white space, find end of word.
2089: * Otherwise find start of next word.
2090: */
2091: if (cls() == 0)
2092: {
2093: if (end_word(count, type, TRUE, TRUE) == FAIL)
2094: return FAIL;
2095: }
2096: else
2097: {
2098: if (fwd_word(count, type, TRUE) == FAIL)
2099: return FAIL;
2100: /*
2101: * If end is just past a new-line, we don't want to include the first
2102: * character on the line
2103: */
2104: if (oneleft() == FAIL) /* put cursor on last char of area */
2105: inclusive = FALSE;
2106: else
2107: {
2108: pos = curwin->w_cursor; /* save cursor position */
2109: /*
2110: * If we don't include white space at the end, move the start to
2111: * include some white space there. This makes "d." work better on
2112: * the last word in a sentence. Don't delete white space at start
2113: * of line (indent).
2114: */
2115: if (cls() != 0)
2116: {
2117: curwin->w_cursor = start;
2118: if (oneleft() == OK)
2119: {
2120: back_in_line();
2121: if (cls() == 0 && curwin->w_cursor.col > 0)
2122: start = curwin->w_cursor;
2123: }
2124: }
2125: curwin->w_cursor = pos; /* put cursor back at end */
2126: }
2127: }
2128: if (VIsual_active)
2129: {
2130: /* should do something when inclusive == FALSE ! */
2131: VIsual = start;
2132: VIsual_mode = 'v';
2133: update_curbuf(NOT_VALID); /* update the inversion */
2134: }
2135: else
2136: {
2137: curbuf->b_op_start = start;
2138: op_motion_type = MCHAR;
2139: op_inclusive = inclusive;
2140: }
2141: return OK;
2142: }
2143:
2144: /*
2145: * Find sentence under the cursor, cursor at end.
2146: */
2147: int
2148: current_sent(count)
2149: long count;
2150: {
2151: FPOS start;
2152: FPOS pos;
2153: int start_blank;
2154: int c;
2155:
2156: pos = curwin->w_cursor;
2157: start = pos;
2158:
2159: /*
2160: * When visual area is bigger than one character: Extend it.
2161: */
2162: if (VIsual_active && !equal(curwin->w_cursor, VIsual))
2163: {
2164: if (lt(pos, VIsual))
2165: {
2166: /*
2167: * Do a "sentence backward" on the next character.
2168: * If we end up on the same position, we were already at the start
2169: * of a sentence
2170: */
2171: if (incl(&curwin->w_cursor) == -1)
2172: return FAIL;
2173: findsent(BACKWARD, 1L);
2174: start = curwin->w_cursor;
2175: if (count > 1)
2176: findsent(BACKWARD, count - 1);
2177: /*
2178: * When at start of sentence: Include blanks in front of sentence.
2179: * Use current_word() to cross line boundaries.
2180: * If we don't end up on a blank or on an empty line, go back to
2181: * the start of the previous sentence.
2182: */
2183: if (equal(pos, start))
2184: {
2185: current_word(1L, 0);
2186: c = gchar_cursor();
2187: if (c != NUL && !vim_iswhite(c))
2188: findsent(BACKWARD, 1L);
2189: }
2190:
2191: }
2192: else
2193: {
2194: /*
2195: * When one char before start of sentence: Don't include blanks in
2196: * front of next sentence.
2197: * Else go count sentences forward.
2198: */
2199: findsent(FORWARD, 1L);
2200: incl(&pos);
2201: if (equal(pos, curwin->w_cursor))
2202: {
2203: findsent(FORWARD, count);
2204: find_first_blank(&curwin->w_cursor);
2205: }
2206: else if (count > 1)
2207: findsent(FORWARD, count - 1);
2208: decl(&curwin->w_cursor);
2209: }
2210: return OK;
2211: }
2212:
2213: /*
2214: * Find start of next sentence.
2215: */
2216: findsent(FORWARD, 1L);
2217:
2218: /*
2219: * If cursor started on blank, check if it is just before the start of the
2220: * next sentence.
2221: */
2222: while (vim_iswhite(gchar(&pos)))
2223: incl(&pos);
2224: if (equal(pos, curwin->w_cursor))
2225: {
2226: start_blank = TRUE;
2227: /*
2228: * go back to first blank
2229: */
2230: while (decl(&start) != -1)
2231: {
2232: if (!vim_iswhite(gchar(&start)))
2233: {
2234: incl(&start);
2235: break;
2236: }
2237: }
2238: }
2239: else
2240: {
2241: start_blank = FALSE;
2242: findsent(BACKWARD, 1L);
2243: start = curwin->w_cursor;
2244: }
2245: findsent(FORWARD, count);
2246:
2247: /*
2248: * If the blank in front of the sentence is included, exclude the blanks
2249: * at the end of the sentence, go back to the first blank.
2250: */
2251: if (start_blank)
2252: find_first_blank(&curwin->w_cursor);
2253: else
2254: {
2255: /*
2256: * If there are no trailing blanks, try to include leading blanks
2257: */
2258: pos = curwin->w_cursor;
2259: decl(&pos);
2260: if (!vim_iswhite(gchar(&pos)))
2261: find_first_blank(&start);
2262: }
2263:
2264: if (VIsual_active)
2265: {
2266: VIsual = start;
2267: VIsual_mode = 'v';
2268: decl(&curwin->w_cursor); /* don't include the cursor char */
2269: update_curbuf(NOT_VALID); /* update the inversion */
2270: }
2271: else
2272: {
2273: curbuf->b_op_start = start;
2274: op_motion_type = MCHAR;
2275: op_inclusive = FALSE;
2276: }
2277: return OK;
2278: }
2279:
2280: int
2281: current_block(what, count)
2282: int what; /* '(' or '{' */
2283: long count;
2284: {
2285: FPOS old_pos;
2286: FPOS *pos = NULL;
2287: FPOS start_pos;
2288: FPOS *end_pos;
2289: FPOS old_start, old_end;
2290: int inclusive = FALSE;
2291: int other;
2292:
2293: old_pos = curwin->w_cursor;
2294: if (what == '{')
2295: other = '}';
2296: else
2297: other = ')';
2298:
2299: old_end = curwin->w_cursor; /* remember where we started */
2300: old_start = old_end;
2301:
2302: /*
2303: * If we start on '(', '{', ')' or '}', use the whole block inclusive.
2304: */
2305: if (!VIsual_active || (VIsual.lnum == curwin->w_cursor.lnum &&
2306: VIsual.col == curwin->w_cursor.col))
2307: {
2308: if (what == '{') /* ignore indent */
2309: while (inindent(1))
2310: if (inc_cursor() != 0)
2311: break;
2312: if (gchar_cursor() == what) /* cursor on '(' or '{' */
2313: {
2314: ++curwin->w_cursor.col;
2315: inclusive = TRUE;
2316: }
2317: else if (gchar_cursor() == other) /* cursor on ')' or '}' */
2318: inclusive = TRUE;
2319: }
2320: else if (lt(VIsual, curwin->w_cursor))
2321: {
2322: old_start = VIsual;
2323: curwin->w_cursor = VIsual; /* cursor at low end of Visual */
2324: }
2325: else
2326: old_end = VIsual;
2327:
2328: /*
2329: * Search backwards for unclosed '(' or '{'.
2330: * put this position in start_pos.
2331: */
2332: while (count--)
2333: {
2334: if ((pos = findmatch(what)) == NULL)
2335: break;
2336: curwin->w_cursor = *pos;
2337: start_pos = *pos; /* the findmatch for end_pos will overwrite *pos */
2338: }
2339:
2340: /*
2341: * Search for matching ')' or '}'.
2342: * Put this position in curwin->w_cursor.
2343: */
2344: if (pos == NULL || (end_pos = findmatch(other)) == NULL)
2345: {
2346: curwin->w_cursor = old_pos;
2347: return FAIL;
2348: }
2349: curwin->w_cursor = *end_pos;
2350:
2351: /*
2352: * Try to exclude the '(', '{', ')' and '}'.
2353: * If the ending '}' is only preceded by indent, skip that indent.
2354: * But only if the resulting area is not smaller than what we started with.
2355: */
2356: if (!inclusive)
2357: {
2358: incl(&start_pos);
2359: old_pos = curwin->w_cursor;
2360: decl(&curwin->w_cursor);
2361: if (what == '{')
2362: while (inindent(0))
2363: if (decl(&curwin->w_cursor) != 0)
2364: break;
2365: if (!lt(start_pos, old_start) && !lt(old_end, curwin->w_cursor))
2366: {
2367: decl(&start_pos);
2368: curwin->w_cursor = old_pos;
2369: }
2370: }
2371:
2372: if (VIsual_active)
2373: {
2374: VIsual = start_pos;
2375: VIsual_mode = 'v';
2376: update_curbuf(NOT_VALID); /* update the inversion */
2377: showmode();
2378: }
2379: else
2380: {
2381: curbuf->b_op_start = start_pos;
2382: op_motion_type = MCHAR;
2383: op_inclusive = TRUE;
2384: }
2385:
2386: return OK;
2387: }
2388:
2389: int
2390: current_par(type, count)
2391: int type; /* 'p' for paragraph, 'S' for section */
2392: long count;
2393: {
2394: linenr_t start;
2395: linenr_t end;
2396: int white_in_front;
2397: int dir;
2398: int start_is_white;
2399: int retval = OK;
2400:
2401: if (type == 'S') /* not implemented yet */
2402: return FAIL;
2403:
2404: start = curwin->w_cursor.lnum;
2405:
2406: /*
2407: * When visual area is more than one line: extend it.
2408: */
2409: if (VIsual_active && start != VIsual.lnum)
2410: {
2411: if (start < VIsual.lnum)
2412: dir = BACKWARD;
2413: else
2414: dir = FORWARD;
2415: while (count--)
2416: {
2417: if (start == (dir == BACKWARD ? 1 : curbuf->b_ml.ml_line_count))
2418: retval = FAIL;
2419:
2420: start_is_white = -1;
2421: for (;;)
2422: {
2423: if (start == (dir == BACKWARD ? 1 : curbuf->b_ml.ml_line_count))
2424: break;
2425: if (start_is_white >= 0 &&
2426: (start_is_white != linewhite(start + dir) ||
2427: startPS(start + (dir > 0 ? 1 : 0), 0, 0)))
2428: break;
2429: start += dir;
2430: if (start_is_white < 0)
2431: start_is_white = linewhite(start);
2432: }
2433: }
2434: curwin->w_cursor.lnum = start;
2435: curwin->w_cursor.col = 0;
2436: return retval;
2437: }
2438:
2439: /*
2440: * First move back to the start of the paragraph or white lines
2441: */
2442: white_in_front = linewhite(start);
2443: while (start > 1)
2444: {
2445: if (white_in_front) /* stop at first white line */
2446: {
2447: if (!linewhite(start - 1))
2448: break;
2449: }
2450: else /* stop at first non-white line of start of paragraph */
2451: {
2452: if (linewhite(start - 1) || startPS(start, 0, 0))
2453: break;
2454: }
2455: --start;
2456: }
2457:
2458: /*
2459: * Move past the end of the white lines.
2460: */
2461: end = start;
2462: while (linewhite(end) && end < curbuf->b_ml.ml_line_count)
2463: ++end;
2464:
2465: --end;
2466: while (count--)
2467: {
2468: if (end == curbuf->b_ml.ml_line_count)
2469: return FAIL;
2470:
2471: ++end;
2472: /*
2473: * skip to end of paragraph
2474: */
2475: while (end < curbuf->b_ml.ml_line_count &&
2476: !linewhite(end + 1) && !startPS(end + 1, 0, 0))
2477: ++end;
2478:
2479: if (count == 0 && white_in_front)
2480: break;
2481:
2482: /*
2483: * skip to end of white lines after paragraph
2484: */
2485: while (end < curbuf->b_ml.ml_line_count && linewhite(end + 1))
2486: ++end;
2487: }
2488:
2489: /*
2490: * If there are no empty lines at the end, try to find some empty lines at
2491: * the start (unless that has been done already).
2492: */
2493: if (!white_in_front && !linewhite(end))
2494: while (start > 1 && linewhite(start - 1))
2495: --start;
2496:
2497: if (VIsual_active)
2498: {
2499: VIsual.lnum = start;
2500: VIsual_mode = 'V';
2501: update_curbuf(NOT_VALID); /* update the inversion */
2502: showmode();
2503: }
2504: else
2505: {
2506: curbuf->b_op_start.lnum = start;
2507: op_motion_type = MLINE;
2508: }
2509: curwin->w_cursor.lnum = end;
2510: curwin->w_cursor.col = 0;
2511:
2512: return OK;
2513: }
2514:
2515: /*
2516: * linewhite -- return TRUE if line 'lnum' is empty or has white chars only.
2517: */
2518: int
2519: linewhite(lnum)
2520: linenr_t lnum;
2521: {
2522: char_u *p;
2523:
2524: p = skipwhite(ml_get(lnum));
2525: return (*p == NUL);
2526: }
2527:
2528: static void
2529: find_first_blank(posp)
2530: FPOS *posp;
2531: {
2532: while (decl(posp) != -1)
2533: {
2534: if (!vim_iswhite(gchar(posp)))
2535: {
2536: incl(posp);
2537: break;
2538: }
2539: }
2540: }
2541:
2542: void
2543: find_pattern_in_path(ptr, len, whole, skip_comments,
2544: type, count, action, start_lnum, end_lnum)
2545: char_u *ptr; /* pointer to search pattern */
2546: int len; /* length of search pattern */
2547: int whole; /* match whole words only */
2548: int skip_comments; /* don't match inside comments */
2549: int type; /* Type of search; are we looking for a type? a
2550: macro? */
2551: long count;
2552: int action; /* What to do when we find it */
2553: linenr_t start_lnum; /* first line to start searching */
2554: linenr_t end_lnum; /* last line for searching */
2555: {
2556: SearchedFile *files; /* Stack of included files */
2557: SearchedFile *bigger; /* When we need more space */
2558: int max_path_depth = 50;
2559: long match_count = 1;
2560:
2561: char_u *pat;
2562: char_u *new_fname;
2563: char_u *curr_fname = curbuf->b_xfilename;
2564: char_u *prev_fname = NULL;
2565: linenr_t lnum;
2566: int depth;
2567: int depth_displayed; /* For type==CHECK_PATH */
2568: int old_files;
2569: int already_searched;
2570: char_u *file_line;
2571: char_u *line;
2572: char_u *p;
2573: char_u *p2 = NUL; /* Init for gcc */
2574: char_u save_char = NUL;
2575: int define_matched;
2576: struct regexp *prog = NULL;
2577: struct regexp *include_prog = NULL;
2578: struct regexp *define_prog = NULL;
2579: int matched = FALSE;
2580: int did_show = FALSE;
2581: int found = FALSE;
2582: int i;
2583:
2584: file_line = alloc(LSIZE);
2585: if (file_line == NULL)
2586: return;
2587:
2588: reg_magic = p_magic;
2589: if (type != CHECK_PATH)
2590: {
2591: pat = alloc(len + 5);
2592: if (pat == NULL)
2593: goto fpip_end;
2594: sprintf((char *)pat, whole ? "\\<%.*s\\>" : "%.*s", len, ptr);
2595: set_reg_ic(pat); /* set reg_ic according to p_ic, p_scs and pat */
2596: prog = vim_regcomp(pat);
2597: vim_free(pat);
2598: if (prog == NULL)
2599: goto fpip_end;
2600: }
2601: reg_ic = FALSE; /* don't ignore case in include and define patterns */
2602: if (*p_inc != NUL)
2603: {
2604: include_prog = vim_regcomp(p_inc);
2605: if (include_prog == NULL)
2606: goto fpip_end;
2607: }
2608: if (type == FIND_DEFINE && *p_def != NUL)
2609: {
2610: define_prog = vim_regcomp(p_def);
2611: if (define_prog == NULL)
2612: goto fpip_end;
2613: }
2614: files = (SearchedFile *)lalloc(max_path_depth * sizeof(SearchedFile), TRUE);
2615: if (files == NULL)
2616: goto fpip_end;
2617: for (i = 0; i < max_path_depth; i++)
2618: {
2619: files[i].fp = NULL;
2620: files[i].name = NULL;
2621: files[i].lnum = 0;
2622: files[i].matched = FALSE;
2623: }
2624: old_files = max_path_depth;
2625: depth = depth_displayed = -1;
2626:
2627: lnum = start_lnum;
2628: if (end_lnum > curbuf->b_ml.ml_line_count)
2629: end_lnum = curbuf->b_ml.ml_line_count;
2630: if (lnum > end_lnum) /* do at least one line */
2631: lnum = end_lnum;
2632: line = ml_get(lnum);
2633:
2634: for (;;)
2635: {
2636: if (include_prog != NULL && vim_regexec(include_prog, line, TRUE))
2637: {
2638: new_fname = get_file_name_in_path(include_prog->endp[0] + 1,
2639: 0, FNAME_EXP);
2640: already_searched = FALSE;
2641: if (new_fname != NULL)
2642: {
2643: /* Check whether we have already searched in this file */
2644: for (i = 0;; i++)
2645: {
2646: if (i == depth + 1)
2647: i = old_files;
2648: if (i == max_path_depth)
2649: break;
2650: if (STRCMP(new_fname, files[i].name) == 0)
2651: {
2652: if (type != CHECK_PATH &&
2653: action == ACTION_SHOW_ALL && files[i].matched)
2654: {
2655: msg_outchar('\n'); /* cursor below last one */
2656: if (!got_int) /* don't display if 'q'
2657: typed at "--more--"
2658: mesage */
2659: {
2660: set_highlight('d'); /* Same as for dirs */
2661: start_highlight();
2662: msg_home_replace(new_fname);
2663: stop_highlight();
2664: MSG_OUTSTR(" (includes previously listed match)");
2665: prev_fname = NULL;
2666: }
2667: }
2668: vim_free(new_fname);
2669: new_fname = NULL;
2670: already_searched = TRUE;
2671: break;
2672: }
2673: }
2674: }
2675:
2676: if (type == CHECK_PATH && (action == ACTION_SHOW_ALL ||
2677: (new_fname == NULL && !already_searched)))
2678: {
2679: if (did_show)
2680: msg_outchar('\n'); /* cursor below last one */
2681: else
2682: {
2683: gotocmdline(TRUE); /* cursor at status line */
2684: set_highlight('t'); /* Highlight title */
2685: start_highlight();
2686: MSG_OUTSTR("--- Included files ");
2687: if (action != ACTION_SHOW_ALL)
2688: MSG_OUTSTR("not found ");
2689: MSG_OUTSTR("in path ---\n");
2690: stop_highlight();
2691: }
2692: did_show = TRUE;
2693: while (depth_displayed < depth && !got_int)
2694: {
2695: ++depth_displayed;
2696: for (i = 0; i < depth_displayed; i++)
2697: MSG_OUTSTR(" ");
2698: msg_home_replace(files[depth_displayed].name);
2699: MSG_OUTSTR(" -->\n");
2700: }
2701: if (!got_int) /* don't display if 'q' typed
2702: for "--more--" message */
2703: {
2704: for (i = 0; i <= depth_displayed; i++)
2705: MSG_OUTSTR(" ");
2706: set_highlight('d'); /* Same as for directories */
2707: start_highlight();
2708: /*
2709: * Isolate the file name.
2710: * Include the surrounding "" or <> if present.
2711: */
2712: for (p = include_prog->endp[0] + 1; !isfilechar(*p); p++)
2713: ;
2714: for (i = 0; isfilechar(p[i]); i++)
2715: ;
2716: if (p[-1] == '"' || p[-1] == '<')
2717: {
2718: --p;
2719: ++i;
2720: }
2721: if (p[i] == '"' || p[i] == '>')
2722: ++i;
2723: save_char = p[i];
2724: p[i] = NUL;
2725: msg_outstr(p);
2726: p[i] = save_char;
2727: stop_highlight();
2728: if (new_fname == NULL && action == ACTION_SHOW_ALL)
2729: {
2730: if (already_searched)
2731: MSG_OUTSTR(" (Already listed)");
2732: else
2733: MSG_OUTSTR(" NOT FOUND");
2734: }
2735: }
2736: flushbuf(); /* output each line directly */
2737: }
2738:
2739: if (new_fname != NULL)
2740: {
2741: /* Push the new file onto the file stack */
2742: if (depth + 1 == old_files)
2743: {
2744: bigger = (SearchedFile *)lalloc(max_path_depth * 2
2745: * sizeof(SearchedFile), TRUE);
2746: if (bigger != NULL)
2747: {
2748: for (i = 0; i <= depth; i++)
2749: bigger[i] = files[i];
2750: for (i = depth + 1; i < old_files + max_path_depth; i++)
2751: {
2752: bigger[i].fp = NULL;
2753: bigger[i].name = NULL;
2754: bigger[i].lnum = 0;
2755: bigger[i].matched = FALSE;
2756: }
2757: for (i = old_files; i < max_path_depth; i++)
2758: bigger[i + max_path_depth] = files[i];
2759: old_files += max_path_depth;
2760: max_path_depth *= 2;
2761: vim_free(files);
2762: files = bigger;
2763: }
2764: }
2765: if ((files[depth + 1].fp = fopen((char *)new_fname, "r"))
2766: == NULL)
2767: vim_free(new_fname);
2768: else
2769: {
2770: if (++depth == old_files)
2771: {
2772: /*
2773: * lalloc() for 'bigger' must have failed above. We
2774: * will forget one of our already visited files now.
2775: */
2776: vim_free(files[old_files].name);
2777: ++old_files;
2778: }
2779: files[depth].name = curr_fname = new_fname;
2780: files[depth].lnum = 0;
2781: files[depth].matched = FALSE;
2782: }
2783: }
2784: }
2785: else
2786: {
2787: /*
2788: * Check if the line is a define (type == FIND_DEFINE)
2789: */
2790: p = line;
2791: define_matched = FALSE;
2792: if (define_prog != NULL && vim_regexec(define_prog, line, TRUE))
2793: {
2794: /*
2795: * Pattern must be first identifier after 'define', so skip
2796: * to that position before checking for match of pattern. Also
2797: * don't let it match beyond the end of this identifier.
2798: */
2799: p = define_prog->endp[0] + 1;
2800: while (*p && !isidchar(*p))
2801: p++;
2802: p2 = p;
2803: while (*p2 && isidchar(*p2))
2804: p2++;
2805: save_char = *p2;
2806: *p2 = NUL;
2807: define_matched = TRUE;
2808: }
2809:
2810: /*
2811: * Look for a match. Don't do this if we are looking for a
2812: * define and this line didn't match define_prog above.
2813: */
2814: if ((define_prog == NULL || define_matched) &&
2815: prog != NULL && vim_regexec(prog, p, p == line))
2816: {
2817: matched = TRUE;
2818: /*
2819: * Check if the line is not a comment line (unless we are
2820: * looking for a define). A line starting with "# define" is
2821: * not considered to be a comment line.
2822: */
2823: if (!define_matched && skip_comments)
2824: {
2825: fo_do_comments = TRUE;
2826: if ((*line != '#' ||
2827: STRNCMP(skipwhite(line + 1), "define", 6) != 0) &&
2828: get_leader_len(line, NULL))
2829: matched = FALSE;
2830:
2831: /*
2832: * Also check for a "/ *" or "/ /" before the match.
2833: * Skips lines like "int idx; / * normal index * /" when
2834: * looking for "normal".
2835: */
2836: else
2837: for (p = line; *p && p < prog->startp[0]; ++p)
2838: if (p[0] == '/' && (p[1] == '*' || p[1] == '/'))
2839: {
2840: matched = FALSE;
2841: break;
2842: }
2843: fo_do_comments = FALSE;
2844: }
2845: }
2846: if (define_matched)
2847: *p2 = save_char;
2848: }
2849: if (matched)
2850: {
2851: #ifdef INSERT_EXPAND
2852: if (action == ACTION_EXPAND)
2853: {
2854: if (depth == -1 && lnum == curwin->w_cursor.lnum)
2855: break;
2856: found = TRUE;
2857: p = prog->startp[0];
2858: while (iswordchar(*p))
2859: ++p;
2860: if (add_completion_and_infercase(prog->startp[0],
2861: (int)(p - prog->startp[0]),
2862: curr_fname == curbuf->b_xfilename ? NULL : curr_fname,
2863: FORWARD) == RET_ERROR)
2864: break;
2865: }
2866: else
2867: #endif
2868: if (action == ACTION_SHOW_ALL)
2869: {
2870: found = TRUE;
2871: if (!did_show)
2872: gotocmdline(TRUE); /* cursor at status line */
2873: if (curr_fname != prev_fname)
2874: {
2875: if (did_show)
2876: msg_outchar('\n'); /* cursor below last one */
2877: if (!got_int) /* don't display if 'q' typed
2878: at "--more--" mesage */
2879: {
2880: set_highlight('d'); /* Same as for directories */
2881: start_highlight();
2882: msg_home_replace(curr_fname);
2883: stop_highlight();
2884: }
2885: prev_fname = curr_fname;
2886: }
2887: did_show = TRUE;
2888: if (!got_int)
2889: show_pat_in_path(line, type, TRUE, action,
2890: (depth == -1) ? NULL : files[depth].fp,
2891: (depth == -1) ? &lnum : &files[depth].lnum,
2892: match_count++);
2893:
2894: /* Set matched flag for this file and all the ones that
2895: * include it */
2896: for (i = 0; i <= depth; ++i)
2897: files[i].matched = TRUE;
2898: }
2899: else if (--count <= 0)
2900: {
2901: found = TRUE;
2902: if (depth == -1 && lnum == curwin->w_cursor.lnum)
2903: EMSG("Match is on current line");
2904: else if (action == ACTION_SHOW)
2905: {
2906: show_pat_in_path(line, type, did_show, action,
2907: (depth == -1) ? NULL : files[depth].fp,
2908: (depth == -1) ? &lnum : &files[depth].lnum, 1L);
2909: did_show = TRUE;
2910: }
2911: else
2912: {
2913: if (action == ACTION_SPLIT)
2914: {
2915: if (win_split(0, FALSE) == FAIL)
2916: break;
2917: }
2918: if (depth == -1)
2919: {
2920: setpcmark();
2921: curwin->w_cursor.lnum = lnum;
2922: }
2923: else
2924: if (getfile(0, files[depth].name, NULL, TRUE,
2925: files[depth].lnum) > 0)
2926: break; /* failed to jump to file */
2927: }
2928: if (action != ACTION_SHOW)
2929: {
2930: curwin->w_cursor.col = prog->startp[0] - line;
2931: curwin->w_set_curswant = TRUE;
2932: }
2933: break;
2934: }
2935: matched = FALSE;
2936: }
2937: line_breakcheck();
2938: if (got_int)
2939: break;
2940: while (depth >= 0)
2941: {
2942: if (!vim_fgets(line = file_line, LSIZE, files[depth].fp))
2943: {
2944: ++files[depth].lnum;
2945: break;
2946: }
2947: fclose(files[depth].fp);
2948: --old_files;
2949: files[old_files].name = files[depth].name;
2950: files[old_files].matched = files[depth].matched;
2951: --depth;
2952: curr_fname = (depth == -1) ? curbuf->b_xfilename
2953: : files[depth].name;
2954: if (depth < depth_displayed)
2955: depth_displayed = depth;
2956: }
2957: if (depth < 0)
2958: {
2959: if (++lnum > end_lnum)
2960: break;
2961: line = ml_get(lnum);
2962: }
2963: }
2964: for (i = 0; i <= depth; i++)
2965: {
2966: fclose(files[i].fp);
2967: vim_free(files[i].name);
2968: }
2969: for (i = old_files; i < max_path_depth; i++)
2970: vim_free(files[i].name);
2971: vim_free(files);
2972:
2973: if (type == CHECK_PATH)
2974: {
2975: if (!did_show)
2976: {
2977: if (action != ACTION_SHOW_ALL)
2978: MSG("All included files were found");
2979: else
2980: MSG("No included files");
2981: }
2982: }
2983: else if (!found
2984: #ifdef INSERT_EXPAND
2985: && action != ACTION_EXPAND
2986: #endif
2987: )
2988: {
2989: if (got_int)
2990: emsg(e_interr);
2991: else if (type == FIND_DEFINE)
2992: EMSG("Couldn't find definition");
2993: else
2994: EMSG("Couldn't find pattern");
2995: }
2996: if (action == ACTION_SHOW || action == ACTION_SHOW_ALL)
2997: msg_end();
2998:
2999: fpip_end:
3000: vim_free(file_line);
3001: vim_free(prog);
3002: vim_free(include_prog);
3003: vim_free(define_prog);
3004: }
3005:
3006: static void
3007: show_pat_in_path(line, type, did_show, action, fp, lnum, count)
3008: char_u *line;
3009: int type;
3010: int did_show;
3011: int action;
3012: FILE *fp;
3013: linenr_t *lnum;
3014: long count;
3015: {
3016: char_u *p;
3017:
3018: if (did_show)
3019: msg_outchar('\n'); /* cursor below last one */
3020: else
3021: gotocmdline(TRUE); /* cursor at status line */
3022: if (got_int) /* 'q' typed at "--more--" message */
3023: return;
3024: for (;;)
3025: {
3026: p = line + STRLEN(line) - 1;
3027: if (fp != NULL)
3028: {
3029: /* We used fgets(), so get rid of newline at end */
3030: if (p >= line && *p == '\n')
3031: --p;
3032: if (p >= line && *p == '\r')
3033: --p;
3034: *(p + 1) = NUL;
3035: }
3036: if (action == ACTION_SHOW_ALL)
3037: {
3038: sprintf((char *)IObuff, "%3ld: ", count); /* show match nr */
3039: msg_outstr(IObuff);
3040: set_highlight('n'); /* Highlight line numbers */
3041: start_highlight();
3042: sprintf((char *)IObuff, "%4ld", *lnum); /* show line nr */
3043: msg_outstr(IObuff);
3044: stop_highlight();
3045: MSG_OUTSTR(" ");
3046: }
3047: msg_prt_line(line);
3048: flushbuf(); /* show one line at a time */
3049:
3050: /* Definition continues until line that doesn't end with '\' */
3051: if (got_int || type != FIND_DEFINE || p < line || *p != '\\')
3052: break;
3053:
3054: if (fp != NULL)
3055: {
3056: if (vim_fgets(line, LSIZE, fp)) /* end of file */
3057: break;
3058: ++*lnum;
3059: }
3060: else
3061: {
3062: if (++*lnum > curbuf->b_ml.ml_line_count)
3063: break;
3064: line = ml_get(*lnum);
3065: }
3066: msg_outchar('\n');
3067: }
3068: }
3069:
3070: #ifdef VIMINFO
3071: int
3072: read_viminfo_search_pattern(line, fp, force)
3073: char_u *line;
3074: FILE *fp;
3075: int force;
3076: {
3077: char_u *lp;
3078: char_u **pattern;
3079:
3080: lp = line;
3081: if (lp[0] == '~')
3082: lp++;
3083: if (lp[0] == '/')
3084: pattern = &search_pattern;
3085: else
3086: pattern = &subst_pattern;
3087: if (*pattern != NULL && force)
3088: vim_free(*pattern);
3089: if (force || *pattern == NULL)
3090: {
3091: viminfo_readstring(lp);
3092: *pattern = strsave(lp + 1);
3093: if (line[0] == '~')
3094: last_pattern = *pattern;
3095: }
3096: return vim_fgets(line, LSIZE, fp);
3097: }
3098:
3099: void
3100: write_viminfo_search_pattern(fp)
3101: FILE *fp;
3102: {
3103: if (get_viminfo_parameter('/') != 0)
3104: {
3105: if (search_pattern != NULL)
3106: {
3107: fprintf(fp, "\n# Last Search Pattern:\n");
3108: fprintf(fp, "%s/", (last_pattern == search_pattern) ? "~" : "");
3109: viminfo_writestring(fp, search_pattern);
3110: }
3111: if (subst_pattern != NULL)
3112: {
3113: fprintf(fp, "\n# Last Substitute Search Pattern:\n");
3114: fprintf(fp, "%s&", (last_pattern == subst_pattern) ? "~" : "");
3115: viminfo_writestring(fp, subst_pattern);
3116: }
3117: }
3118: }
3119: #endif /* VIMINFO */
3120:
3121: /*
3122: * Give a warning message.
3123: * Use 'w' highlighting and may repeat the message after redrawing
3124: */
3125: static void
3126: give_warning(message)
3127: char_u *message;
3128: {
3129: (void)set_highlight('w');
3130: msg_highlight = TRUE;
3131: if (msg(message) && !msg_scroll)
3132: {
3133: keep_msg = message;
3134: keep_msg_highlight = 'w';
3135: }
3136: msg_didout = FALSE; /* overwrite this message */
3137: msg_col = 0;
3138: }