2 * Copyright (c) 1992, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
7 * See the LICENSE file for redistribution information.
13 static const char sccsid
[] = "$Id: v_search.c,v 10.30 2001/09/11 20:52:46 skimo Exp $ (Berkeley) $Date: 2001/09/11 20:52:46 $";
16 #include <sys/types.h>
17 #include <sys/queue.h>
20 #include <bitstring.h>
28 #include "../common/common.h"
30 #include "../ipc/ip.h"
32 static int v_exaddr
__P((SCR
*, VICMD
*, dir_t
));
33 static int v_search
__P((SCR
*, VICMD
*, CHAR_T
*, size_t, u_int
, dir_t
));
36 * v_srch -- [count]?RE[? offset]
37 * Ex address search backward.
39 * PUBLIC: int v_searchb __P((SCR *, VICMD *));
42 v_searchb(SCR
*sp
, VICMD
*vp
)
44 return (v_exaddr(sp
, vp
, BACKWARD
));
48 * v_searchf -- [count]/RE[/ offset]
49 * Ex address search forward.
51 * PUBLIC: int v_searchf __P((SCR *, VICMD *));
54 v_searchf(SCR
*sp
, VICMD
*vp
)
56 return (v_exaddr(sp
, vp
, FORWARD
));
61 * Do a vi search (which is really an ex address).
64 v_exaddr(SCR
*sp
, VICMD
*vp
, dir_t dir
)
66 static EXCMDLIST fake
= { L("search") };
71 size_t len
, s_cno
, tlen
;
80 * If using the search command as a motion, any addressing components
81 * are lost, i.e. y/ptrn/+2, when repeated, is the same as y/ptrn/.
83 if (F_ISSET(vp
, VC_ISDOT
))
84 return (v_search(sp
, vp
,
85 NULL
, 0, SEARCH_PARSE
| SEARCH_MSG
| SEARCH_SET
, dir
));
87 /* Get the search pattern. */
88 if (v_tcmd(sp
, vp
, dir
== BACKWARD
? CH_BSEARCH
: CH_FSEARCH
,
89 TXT_BS
| TXT_CR
| TXT_ESCAPE
| TXT_PROMPT
|
90 (O_ISSET(sp
, O_SEARCHINCR
) ? TXT_SEARCHINCR
: 0)))
93 tp
= sp
->tiq
.cqh_first
;
95 /* If the user backspaced over the prompt, do nothing. */
96 if (tp
->term
== TERM_BS
)
100 * If the user was doing an incremental search, then we've already
101 * updated the cursor and moved to the right location. Return the
102 * correct values, we're done.
104 if (tp
->term
== TERM_SEARCH
) {
105 vp
->m_stop
.lno
= sp
->lno
;
106 vp
->m_stop
.cno
= sp
->cno
;
108 return (v_correct(sp
, vp
, 0));
109 vp
->m_final
= vp
->m_stop
;
114 * If the user entered <escape> or <carriage-return>, the length is
115 * 1 and the right thing will happen, i.e. the prompt will be used
116 * as a command character.
118 * Build a fake ex command structure.
121 wp
->excmd
.cp
= tp
->lb
;
122 wp
->excmd
.clen
= tp
->len
;
123 F_INIT(&wp
->excmd
, E_VISEARCH
);
127 * Warn if the search wraps. This is a pretty special case, but it's
128 * nice feature that wasn't in the original implementations of ex/vi.
129 * (It was added at some point to System V's version.) This message
130 * is only displayed if there are no keys in the queue. The problem is
131 * the command is going to succeed, and the message is informational,
132 * not an error. If a macro displays it repeatedly, e.g., the pattern
133 * only occurs once in the file and wrapscan is set, you lose big. For
134 * example, if the macro does something like:
136 * :map K /pattern/^MjK
138 * Each search will display the message, but the following "/pattern/"
139 * will immediately overwrite it, with strange results. The System V
140 * vi displays the "wrapped" message multiple times, but because it's
141 * overwritten each time, it's not as noticeable. As we don't discard
142 * messages, it's a real problem for us.
144 if (!KEYS_WAITING(sp
))
145 F_SET(&wp
->excmd
, E_SEARCH_WMSG
);
147 /* Save the current line/column. */
153 * Historically, vi / and ? commands were full-blown ex addresses,
154 * including ';' delimiters, trailing <blank>'s, multiple search
155 * strings (separated by semi-colons) and, finally, full-blown z
156 * commands after the / and ? search strings. (If the search was
157 * being used as a motion, the trailing z command was ignored.
158 * Also, we do some argument checking on the z command, to be sure
159 * that it's not some other random command.) For multiple search
160 * strings, leading <blank>'s at the second and subsequent strings
161 * were eaten as well. This has some (unintended?) side-effects:
162 * the command /ptrn/;3 is legal and results in moving to line 3.
163 * I suppose you could use it to optionally move to line 3...
166 * Historically, if any part of the search command failed, the cursor
167 * remained unmodified (even if ; was used). We have to play games
168 * because the underlying ex parser thinks we're modifying the cursor
169 * as we go, but I think we're compatible with historic practice.
172 * Historically, the command "/STRING/; " failed, apparently it
173 * confused the parser. We're not that compatible.
176 if (ex_range(sp
, cmdp
, &err
))
180 * Remember where any remaining command information is, and clean
181 * up the fake ex command.
190 /* Copy out the new cursor position and make sure it's okay. */
191 switch (cmdp
->addrcnt
) {
193 vp
->m_stop
= cmdp
->addr1
;
196 vp
->m_stop
= cmdp
->addr2
;
199 if (!db_exist(sp
, vp
->m_stop
.lno
)) {
200 ex_badaddr(sp
, &fake
,
201 vp
->m_stop
.lno
== 0 ? A_ZERO
: A_EOF
, NUM_OK
);
207 * Historic practice is that a trailing 'z' was ignored if it was a
208 * motion command. Should probably be an error, but not worth the
212 return (v_correct(sp
, vp
, F_ISSET(cmdp
, E_DELTA
)));
216 * Historically, if it wasn't a motion command, a delta in the search
217 * pattern turns it into a first nonblank movement.
219 nb
= F_ISSET(cmdp
, E_DELTA
);
221 /* Check for the 'z' command. */
226 /* No blanks, just like the z command. */
227 for (t
= cmd
+ 1, tlen
= len
- 1; tlen
> 0; ++t
, --tlen
)
231 (*t
== '-' || *t
== '.' || *t
== '+' || *t
== '^')) {
240 /* The z command will do the nonblank for us. */
245 v_event_push(sp
, NULL
, L("+"), 1, CH_NOMAP
| CH_QUOTED
))
248 /* Push the user's command. */
249 if (v_event_push(sp
, NULL
, cmd
, len
, CH_NOMAP
| CH_QUOTED
))
252 /* Push line number so get correct z display. */
254 sizeof(buf
), "%lu", (u_long
)vp
->m_stop
.lno
);
255 CHAR2INT(sp
, buf
, tlen
, w
, wlen
);
256 if (v_event_push(sp
, NULL
, w
, wlen
, CH_NOMAP
| CH_QUOTED
))
259 /* Don't refresh until after 'z' happens. */
260 F_SET(VIP(sp
), VIP_S_REFRESH
);
263 /* Non-motion commands move to the end of the range. */
264 vp
->m_final
= vp
->m_stop
;
266 F_CLR(vp
, VM_RCM_MASK
);
267 F_SET(vp
, VM_RCM_SETFNB
);
271 err1
: msgq(sp
, M_ERR
,
272 "188|Characters after search string, line offset and/or z command");
273 err2
: vp
->m_final
.lno
= s_lno
;
274 vp
->m_final
.cno
= s_cno
;
280 * Reverse last search.
282 * PUBLIC: int v_searchN __P((SCR *, VICMD *));
285 v_searchN(SCR
*sp
, VICMD
*vp
)
289 switch (sp
->searchdir
) {
300 return (v_search(sp
, vp
, NULL
, 0, SEARCH_PARSE
, dir
));
305 * Repeat last search.
307 * PUBLIC: int v_searchn __P((SCR *, VICMD *));
310 v_searchn(SCR
*sp
, VICMD
*vp
)
312 return (v_search(sp
, vp
, NULL
, 0, SEARCH_PARSE
, sp
->searchdir
));
317 * Test if the character is special in an extended RE.
320 is_especial(CHAR_T c
)
324 * Right-brace is not an ERE special according to IEEE 1003.1-2001.
325 * Right-parenthesis is a special character (so quoting doesn't hurt),
326 * though it has no special meaning in this context, viz. at the
327 * beginning of the string. So we need not quote it. Then again,
328 * see the BUGS section in regex/re_format.7.
329 * The tilde is vi-specific, of course.
331 return (STRCHR(L(".[\\()*+?{|^$~"), c
) && c
);
335 * Rear delimiter for word search when the keyword ends in
336 * (i.e., consists of) a non-word character. See v_searchw below.
338 #define RE_NWSTOP L("([^[:alnum:]_]|$)")
339 #define RE_NWSTOP_LEN (SIZE(RE_NWSTOP) - 1)
342 * v_searchw -- [count]^A
343 * Search for the word under the cursor.
345 * PUBLIC: int v_searchw __P((SCR *, VICMD *));
348 v_searchw(SCR
*sp
, VICMD
*vp
)
351 /* An upper bound for the SIZE of the RE under construction. */
352 size_t len
= VIP(sp
)->klen
+ MAX(RE_WSTART_LEN
, 1)
353 + MAX(RE_WSTOP_LEN
, RE_NWSTOP_LEN
);
357 GET_SPACE_RETW(sp
, bp
, blen
, len
);
360 /* Only the first character can be non-word, see v_curword. */
361 if (inword(VIP(sp
)->keyw
[0]))
362 p
= MEMPCPY(p
, RE_WSTART
, RE_WSTART_LEN
);
363 else if (is_especial(VIP(sp
)->keyw
[0]))
364 p
= MEMPCPY(p
, L("\\"), 1);
366 p
= MEMPCPY(p
, VIP(sp
)->keyw
, VIP(sp
)->klen
);
369 p
= MEMPCPY(p
, RE_WSTOP
, RE_WSTOP_LEN
);
372 * The keyword is a single non-word character.
373 * We want it to stay the same when typing ^A several times
374 * in a row, just the way the other cases behave.
376 p
= MEMPCPY(p
, RE_NWSTOP
, RE_NWSTOP_LEN
);
379 rval
= v_search(sp
, vp
, bp
, len
, SEARCH_SET
| SEARCH_EXTEND
, FORWARD
);
381 FREE_SPACEW(sp
, bp
, blen
);
386 * v_esearch -- <dialog box>
387 * Search command from the screen.
389 * PUBLIC: int v_esearch __P((SCR *, VICMD *));
392 v_esearch(SCR
*sp
, VICMD
*vp
)
400 LF_INIT(SEARCH_NOOPT
);
401 if (FL_ISSET(vp
->ev
.e_flags
, VI_SEARCH_EXT
))
402 LF_SET(SEARCH_EXTEND
);
403 if (FL_ISSET(vp
->ev
.e_flags
, VI_SEARCH_IC
))
405 if (FL_ISSET(vp
->ev
.e_flags
, VI_SEARCH_ICL
))
407 if (FL_ISSET(vp
->ev
.e_flags
, VI_SEARCH_INCR
))
409 if (FL_ISSET(vp
->ev
.e_flags
, VI_SEARCH_LIT
))
410 LF_SET(SEARCH_LITERAL
);
411 if (FL_ISSET(vp
->ev
.e_flags
, VI_SEARCH_WR
))
413 return (v_search(sp
, vp
, vp
->ev
.e_csp
, vp
->ev
.e_len
, flags
,
414 FL_ISSET(vp
->ev
.e_flags
, VI_SEARCH_REV
) ? BACKWARD
: FORWARD
));
419 * The search commands.
422 v_search(SCR
*sp
, VICMD
*vp
, CHAR_T
*ptrn
, size_t plen
, u_int flags
, dir_t dir
)
424 /* Display messages. */
427 /* If it's a motion search, offset past end-of-line is okay. */
433 * Warn if the search wraps. See the comment above, in v_exaddr().
435 if (!KEYS_WAITING(sp
))
441 &vp
->m_start
, &vp
->m_stop
, ptrn
, plen
, NULL
, flags
))
446 &vp
->m_start
, &vp
->m_stop
, ptrn
, plen
, NULL
, flags
))
450 msgq(sp
, M_ERR
, "189|No previous search pattern");
456 /* Correct motion commands, otherwise, simply move to the location. */
458 if (v_correct(sp
, vp
, 0))
461 vp
->m_final
= vp
->m_stop
;
467 * Handle command with a search as the motion.
470 * Historically, commands didn't affect the line searched to/from if the
471 * motion command was a search and the final position was the start/end
472 * of the line. There were some special cases and vi was not consistent;
473 * it was fairly easy to confuse it. For example, given the two lines:
478 * placing the cursor on the 'A' and doing y?$ would so confuse it that 'h'
479 * 'k' and put would no longer work correctly. In any case, we try to do
480 * the right thing, but it's not going to exactly match historic practice.
482 * PUBLIC: int v_correct __P((SCR *, VICMD *, int));
485 v_correct(SCR
*sp
, VICMD
*vp
, int isdelta
)
493 * We may have wrapped if wrapscan was set, and we may have returned
494 * to the position where the cursor started. Historic vi didn't cope
495 * with this well. Yank wouldn't beep, but the first put after the
496 * yank would move the cursor right one column (without adding any
497 * text) and the second would put a copy of the current line. The
498 * change and delete commands would beep, but would leave the cursor
499 * on the colon command line. I believe that there are macros that
500 * depend on delete, at least, failing. For now, commands that use
501 * search as a motion component fail when the search returns to the
502 * original cursor position.
504 if (vp
->m_start
.lno
== vp
->m_stop
.lno
&&
505 vp
->m_start
.cno
== vp
->m_stop
.cno
) {
506 msgq(sp
, M_BERR
, "190|Search wrapped to original position");
512 * Searches become line mode operations if there was a delta specified
513 * to the search pattern.
519 * If the motion is in the reverse direction, switch the start and
520 * stop MARK's so that it's in a forward direction. (There's no
521 * reason for this other than to make the tests below easier. The
522 * code in vi.c:vi() would have done the switch.) Both forward
523 * and backward motions can happen for any kind of search command
524 * because of the wrapscan option.
526 if (vp
->m_start
.lno
> vp
->m_stop
.lno
||
527 vp
->m_start
.lno
== vp
->m_stop
.lno
&&
528 vp
->m_start
.cno
> vp
->m_stop
.cno
) {
530 vp
->m_start
= vp
->m_stop
;
538 * Delete and yank commands move to the end of the range.
542 * Delete and yank commands don't move. Ignore others.
544 vp
->m_final
= vp
->m_start
;
548 * Delta'd searches don't correct based on column positions.
555 * Backward searches starting at column 0, and forward searches ending
556 * at column 0 are corrected to the last column of the previous line.
557 * Otherwise, adjust the starting/ending point to the character before
558 * the current one (this is safe because we know the search had to move
561 * Searches become line mode operations if they start at the first
562 * nonblank and end at column 0 of another line.
564 if (vp
->m_start
.lno
< vp
->m_stop
.lno
&& vp
->m_stop
.cno
== 0) {
565 if (db_get(sp
, --vp
->m_stop
.lno
, DBG_FATAL
, NULL
, &len
))
567 vp
->m_stop
.cno
= len
? len
- 1 : 0;
569 if (nonblank(sp
, vp
->m_start
.lno
, &len
))
571 if (vp
->m_start
.cno
<= len
)