rename O_DIRECTORY to O_TMP_DIRECTORY to avoid conflict with open option
[nvi.git] / vi / v_search.c
blob8318d83f2193a38ceb1a8435bcde687693619d4d
1 /*-
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.
8 */
10 #include "config.h"
12 #ifndef lint
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 $";
14 #endif /* not lint */
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/time.h>
20 #include <bitstring.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <limits.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
28 #include "../common/common.h"
29 #include "vi.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 *));
41 int
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 *));
53 int
54 v_searchf(SCR *sp, VICMD *vp)
56 return (v_exaddr(sp, vp, FORWARD));
60 * v_exaddr --
61 * Do a vi search (which is really an ex address).
63 static int
64 v_exaddr(SCR *sp, VICMD *vp, dir_t dir)
66 static EXCMDLIST fake = { L("search") };
67 EXCMD *cmdp;
68 WIN *wp;
69 TEXT *tp;
70 db_recno_t s_lno;
71 size_t len, s_cno, tlen;
72 int err, nb, type;
73 char buf[20];
74 CHAR_T *cmd, *t;
75 CHAR_T *w;
76 size_t wlen;
79 * !!!
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)))
91 return (1);
93 tp = sp->tiq.cqh_first;
95 /* If the user backspaced over the prompt, do nothing. */
96 if (tp->term == TERM_BS)
97 return (1);
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;
107 if (ISMOTION(vp))
108 return (v_correct(sp, vp, 0));
109 vp->m_final = vp->m_stop;
110 return (0);
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.
120 wp = sp->wp;
121 wp->excmd.cp = tp->lb;
122 wp->excmd.clen = tp->len;
123 F_INIT(&wp->excmd, E_VISEARCH);
126 * XXX
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. */
148 s_lno = sp->lno;
149 s_cno = sp->cno;
152 * !!!
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...
165 * !!!
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.
171 * !!!
172 * Historically, the command "/STRING/; " failed, apparently it
173 * confused the parser. We're not that compatible.
175 cmdp = &wp->excmd;
176 if (ex_range(sp, cmdp, &err))
177 return (1);
180 * Remember where any remaining command information is, and clean
181 * up the fake ex command.
183 cmd = cmdp->cp;
184 len = cmdp->clen;
185 wp->excmd.clen = 0;
187 if (err)
188 goto err2;
190 /* Copy out the new cursor position and make sure it's okay. */
191 switch (cmdp->addrcnt) {
192 case 1:
193 vp->m_stop = cmdp->addr1;
194 break;
195 case 2:
196 vp->m_stop = cmdp->addr2;
197 break;
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);
202 goto err2;
206 * !!!
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
209 * effort.
211 if (ISMOTION(vp))
212 return (v_correct(sp, vp, F_ISSET(cmdp, E_DELTA)));
215 * !!!
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. */
222 if (len != 0) {
223 if (*cmd != 'z')
224 goto err1;
226 /* No blanks, just like the z command. */
227 for (t = cmd + 1, tlen = len - 1; tlen > 0; ++t, --tlen)
228 if (!isdigit(*t))
229 break;
230 if (tlen &&
231 (*t == '-' || *t == '.' || *t == '+' || *t == '^')) {
232 ++t;
233 --tlen;
234 type = 1;
235 } else
236 type = 0;
237 if (tlen)
238 goto err1;
240 /* The z command will do the nonblank for us. */
241 nb = 0;
243 /* Default to z+. */
244 if (!type &&
245 v_event_push(sp, NULL, L("+"), 1, CH_NOMAP | CH_QUOTED))
246 return (1);
248 /* Push the user's command. */
249 if (v_event_push(sp, NULL, cmd, len, CH_NOMAP | CH_QUOTED))
250 return (1);
252 /* Push line number so get correct z display. */
253 tlen = snprintf(buf,
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))
257 return (1);
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;
265 if (nb) {
266 F_CLR(vp, VM_RCM_MASK);
267 F_SET(vp, VM_RCM_SETFNB);
269 return (0);
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;
275 return (1);
279 * v_searchN -- N
280 * Reverse last search.
282 * PUBLIC: int v_searchN __P((SCR *, VICMD *));
285 v_searchN(SCR *sp, VICMD *vp)
287 dir_t dir;
289 switch (sp->searchdir) {
290 case BACKWARD:
291 dir = FORWARD;
292 break;
293 case FORWARD:
294 dir = BACKWARD;
295 break;
296 default:
297 dir = sp->searchdir;
298 break;
300 return (v_search(sp, vp, NULL, 0, SEARCH_PARSE, dir));
304 * v_searchn -- n
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));
316 * v_searchw -- [count]^A
317 * Search for the word under the cursor.
319 * PUBLIC: int v_searchw __P((SCR *, VICMD *));
322 v_searchw(SCR *sp, VICMD *vp)
324 size_t blen, len;
325 int rval;
326 CHAR_T *bp, *p;
328 len = VIP(sp)->klen + RE_WSTART_LEN + RE_WSTOP_LEN;
329 GET_SPACE_RETW(sp, bp, blen, len);
330 MEMCPY(bp, RE_WSTART, RE_WSTART_LEN);
331 p = bp + RE_WSTART_LEN;
332 MEMCPY(p, VIP(sp)->keyw, VIP(sp)->klen);
333 p += VIP(sp)->klen;
334 MEMCPY(p, RE_WSTOP, RE_WSTOP_LEN);
336 rval = v_search(sp, vp, bp, len, SEARCH_SET, FORWARD);
338 FREE_SPACEW(sp, bp, blen);
339 return (rval);
343 * v_esearch -- <dialog box>
344 * Search command from the screen.
346 * PUBLIC: int v_esearch __P((SCR *, VICMD *));
349 v_esearch(SCR *sp, VICMD *vp)
351 MARK m;
352 int flags;
354 m.lno = sp->lno;
355 m.cno = sp->cno;
357 LF_INIT(SEARCH_NOOPT);
358 if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_EXT))
359 LF_SET(SEARCH_EXTEND);
360 if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_IC))
361 LF_SET(SEARCH_IC);
362 if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_ICL))
363 LF_SET(SEARCH_ICL);
364 if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_INCR))
365 LF_SET(SEARCH_INCR);
366 if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_LIT))
367 LF_SET(SEARCH_LITERAL);
368 if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_WR))
369 LF_SET(SEARCH_WRAP);
370 return (v_search(sp, vp, vp->ev.e_csp, vp->ev.e_len, flags,
371 FL_ISSET(vp->ev.e_flags, VI_SEARCH_REV) ? BACKWARD : FORWARD));
375 * v_search --
376 * The search commands.
378 static int
379 v_search(SCR *sp, VICMD *vp, CHAR_T *ptrn, size_t plen, u_int flags, dir_t dir)
381 /* Display messages. */
382 LF_SET(SEARCH_MSG);
384 /* If it's a motion search, offset past end-of-line is okay. */
385 if (ISMOTION(vp))
386 LF_SET(SEARCH_EOL);
389 * XXX
390 * Warn if the search wraps. See the comment above, in v_exaddr().
392 if (!KEYS_WAITING(sp))
393 LF_SET(SEARCH_WMSG);
395 switch (dir) {
396 case BACKWARD:
397 if (b_search(sp,
398 &vp->m_start, &vp->m_stop, ptrn, plen, NULL, flags))
399 return (1);
400 break;
401 case FORWARD:
402 if (f_search(sp,
403 &vp->m_start, &vp->m_stop, ptrn, plen, NULL, flags))
404 return (1);
405 break;
406 case NOTSET:
407 msgq(sp, M_ERR, "189|No previous search pattern");
408 return (1);
409 default:
410 abort();
413 /* Correct motion commands, otherwise, simply move to the location. */
414 if (ISMOTION(vp)) {
415 if (v_correct(sp, vp, 0))
416 return(1);
417 } else
418 vp->m_final = vp->m_stop;
419 return (0);
423 * v_correct --
424 * Handle command with a search as the motion.
426 * !!!
427 * Historically, commands didn't affect the line searched to/from if the
428 * motion command was a search and the final position was the start/end
429 * of the line. There were some special cases and vi was not consistent;
430 * it was fairly easy to confuse it. For example, given the two lines:
432 * abcdefghi
433 * ABCDEFGHI
435 * placing the cursor on the 'A' and doing y?$ would so confuse it that 'h'
436 * 'k' and put would no longer work correctly. In any case, we try to do
437 * the right thing, but it's not going to exactly match historic practice.
439 * PUBLIC: int v_correct __P((SCR *, VICMD *, int));
442 v_correct(SCR *sp, VICMD *vp, int isdelta)
444 dir_t dir;
445 MARK m;
446 size_t len;
449 * !!!
450 * We may have wrapped if wrapscan was set, and we may have returned
451 * to the position where the cursor started. Historic vi didn't cope
452 * with this well. Yank wouldn't beep, but the first put after the
453 * yank would move the cursor right one column (without adding any
454 * text) and the second would put a copy of the current line. The
455 * change and delete commands would beep, but would leave the cursor
456 * on the colon command line. I believe that there are macros that
457 * depend on delete, at least, failing. For now, commands that use
458 * search as a motion component fail when the search returns to the
459 * original cursor position.
461 if (vp->m_start.lno == vp->m_stop.lno &&
462 vp->m_start.cno == vp->m_stop.cno) {
463 msgq(sp, M_BERR, "190|Search wrapped to original position");
464 return (1);
468 * !!!
469 * Searches become line mode operations if there was a delta specified
470 * to the search pattern.
472 if (isdelta)
473 F_SET(vp, VM_LMODE);
476 * If the motion is in the reverse direction, switch the start and
477 * stop MARK's so that it's in a forward direction. (There's no
478 * reason for this other than to make the tests below easier. The
479 * code in vi.c:vi() would have done the switch.) Both forward
480 * and backward motions can happen for any kind of search command
481 * because of the wrapscan option.
483 if (vp->m_start.lno > vp->m_stop.lno ||
484 vp->m_start.lno == vp->m_stop.lno &&
485 vp->m_start.cno > vp->m_stop.cno) {
486 m = vp->m_start;
487 vp->m_start = vp->m_stop;
488 vp->m_stop = m;
489 dir = BACKWARD;
490 } else
491 dir = FORWARD;
494 * BACKWARD:
495 * Delete and yank commands move to the end of the range.
496 * Ignore others.
498 * FORWARD:
499 * Delete and yank commands don't move. Ignore others.
501 vp->m_final = vp->m_start;
504 * !!!
505 * Delta'd searches don't correct based on column positions.
507 if (isdelta)
508 return (0);
511 * !!!
512 * Backward searches starting at column 0, and forward searches ending
513 * at column 0 are corrected to the last column of the previous line.
514 * Otherwise, adjust the starting/ending point to the character before
515 * the current one (this is safe because we know the search had to move
516 * to succeed).
518 * Searches become line mode operations if they start at the first
519 * nonblank and end at column 0 of another line.
521 if (vp->m_start.lno < vp->m_stop.lno && vp->m_stop.cno == 0) {
522 if (db_get(sp, --vp->m_stop.lno, DBG_FATAL, NULL, &len))
523 return (1);
524 vp->m_stop.cno = len ? len - 1 : 0;
525 len = 0;
526 if (nonblank(sp, vp->m_start.lno, &len))
527 return (1);
528 if (vp->m_start.cno <= len)
529 F_SET(vp, VM_LMODE);
530 } else
531 --vp->m_stop.cno;
533 return (0);