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. 6 * 7 * See the LICENSE file for redistribution information. 8 */ 9 10 #include "config.h" 11 12 #ifndef lint 13 static const char sccsid[] = "@(#)v_search.c 10.18 (Berkeley) 9/19/96"; 14 #endif /* not lint */ 15 16 #include <sys/types.h> 17 #include <sys/queue.h> 18 #include <sys/time.h> 19 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> 27 28 #include "../common/common.h" 29 #include "vi.h" 30 31 static int v_exaddr __P((SCR *, VICMD *, dir_t)); 32 static int v_search __P((SCR *, VICMD *, char *, size_t, u_int, dir_t)); 33 34 /* 35 * v_srch -- [count]?RE[? offset] 36 * Ex address search backward. 37 * 38 * PUBLIC: int v_searchb __P((SCR *, VICMD *)); 39 */ 40 int 41 v_searchb(sp, vp) 42 SCR *sp; 43 VICMD *vp; 44 { 45 return (v_exaddr(sp, vp, BACKWARD)); 46 } 47 48 /* 49 * v_searchf -- [count]/RE[/ offset] 50 * Ex address search forward. 51 * 52 * PUBLIC: int v_searchf __P((SCR *, VICMD *)); 53 */ 54 int 55 v_searchf(sp, vp) 56 SCR *sp; 57 VICMD *vp; 58 { 59 return (v_exaddr(sp, vp, FORWARD)); 60 } 61 62 /* 63 * v_exaddr -- 64 * Do a vi search (which is really an ex address). 65 */ 66 static int 67 v_exaddr(sp, vp, dir) 68 SCR *sp; 69 VICMD *vp; 70 dir_t dir; 71 { 72 static EXCMDLIST fake = { "search" }; 73 EXCMD *cmdp; 74 GS *gp; 75 TEXT *tp; 76 recno_t s_lno; 77 size_t len, s_cno, tlen; 78 int err, nb, type; 79 char *cmd, *t, buf[20]; 80 81 /* 82 * !!! 83 * If using the search command as a motion, any addressing components 84 * are lost, i.e. y/ptrn/+2, when repeated, is the same as y/ptrn/. 85 */ 86 if (F_ISSET(vp, VC_ISDOT)) 87 return (v_search(sp, vp, 88 NULL, 0, SEARCH_PARSE | SEARCH_MSG | SEARCH_SET, dir)); 89 90 /* Get the search pattern. */ 91 if (v_tcmd(sp, vp, dir == BACKWARD ? CH_BSEARCH : CH_FSEARCH, 92 TXT_BS | TXT_CR | TXT_ESCAPE | TXT_PROMPT | 93 (O_ISSET(sp, O_SEARCHINCR) ? TXT_SEARCHINCR : 0))) 94 return (1); 95 96 tp = sp->tiq.cqh_first; 97 98 /* If the user backspaced over the prompt, do nothing. */ 99 if (tp->term == TERM_BS) 100 return (1); 101 102 /* 103 * If the user was doing an incremental search, then we've already 104 * updated the cursor and moved to the right location. Return the 105 * correct values, we're done. 106 */ 107 if (tp->term == TERM_SEARCH) { 108 vp->m_stop.lno = sp->lno; 109 vp->m_stop.cno = sp->cno; 110 if (ISMOTION(vp)) 111 return (v_correct(sp, vp, 0)); 112 vp->m_final = vp->m_stop; 113 return (0); 114 } 115 116 /* 117 * If the user entered <escape> or <carriage-return>, the length is 118 * 1 and the right thing will happen, i.e. the prompt will be used 119 * as a command character. 120 * 121 * Build a fake ex command structure. 122 */ 123 gp = sp->gp; 124 gp->excmd.cp = tp->lb; 125 gp->excmd.clen = tp->len; 126 F_INIT(&gp->excmd, E_VISEARCH); 127 128 /* 129 * XXX 130 * Warn if the search wraps. This is a pretty special case, but it's 131 * nice feature that wasn't in the original implementations of ex/vi. 132 * (It was added at some point to System V's version.) This message 133 * is only displayed if there are no keys in the queue. The problem is 134 * the command is going to succeed, and the message is informational, 135 * not an error. If a macro displays it repeatedly, e.g., the pattern 136 * only occurs once in the file and wrapscan is set, you lose big. For 137 * example, if the macro does something like: 138 * 139 * :map K /pattern/^MjK 140 * 141 * Each search will display the message, but the following "/pattern/" 142 * will immediately overwrite it, with strange results. The System V 143 * vi displays the "wrapped" message multiple times, but because it's 144 * overwritten each time, it's not as noticeable. As we don't discard 145 * messages, it's a real problem for us. 146 */ 147 if (!KEYS_WAITING(sp)) 148 F_SET(&gp->excmd, E_SEARCH_WMSG); 149 150 /* Save the current line/column. */ 151 s_lno = sp->lno; 152 s_cno = sp->cno; 153 154 /* 155 * !!! 156 * Historically, vi / and ? commands were full-blown ex addresses, 157 * including ';' delimiters, trailing <blank>'s, multiple search 158 * strings (separated by semi-colons) and, finally, full-blown z 159 * commands after the / and ? search strings. (If the search was 160 * being used as a motion, the trailing z command was ignored. 161 * Also, we do some argument checking on the z command, to be sure 162 * that it's not some other random command.) For multiple search 163 * strings, leading <blank>'s at the second and subsequent strings 164 * were eaten as well. This has some (unintended?) side-effects: 165 * the command /ptrn/;3 is legal and results in moving to line 3. 166 * I suppose you could use it to optionally move to line 3... 167 * 168 * !!! 169 * Historically, if any part of the search command failed, the cursor 170 * remained unmodified (even if ; was used). We have to play games 171 * because the underlying ex parser thinks we're modifying the cursor 172 * as we go, but I think we're compatible with historic practice. 173 * 174 * !!! 175 * Historically, the command "/STRING/; " failed, apparently it 176 * confused the parser. We're not that compatible. 177 */ 178 cmdp = &gp->excmd; 179 if (ex_range(sp, cmdp, &err)) 180 return (1); 181 182 /* 183 * Remember where any remaining command information is, and clean 184 * up the fake ex command. 185 */ 186 cmd = cmdp->cp; 187 len = cmdp->clen; 188 gp->excmd.clen = 0; 189 190 if (err) 191 goto err2; 192 193 /* Copy out the new cursor position and make sure it's okay. */ 194 switch (cmdp->addrcnt) { 195 case 1: 196 vp->m_stop = cmdp->addr1; 197 break; 198 case 2: 199 vp->m_stop = cmdp->addr2; 200 break; 201 } 202 if (!db_exist(sp, vp->m_stop.lno)) { 203 ex_badaddr(sp, &fake, 204 vp->m_stop.lno == 0 ? A_ZERO : A_EOF, NUM_OK); 205 goto err2; 206 } 207 208 /* 209 * !!! 210 * Historic practice is that a trailing 'z' was ignored if it was a 211 * motion command. Should probably be an error, but not worth the 212 * effort. 213 */ 214 if (ISMOTION(vp)) 215 return (v_correct(sp, vp, F_ISSET(cmdp, E_DELTA))); 216 217 /* 218 * !!! 219 * Historically, if it wasn't a motion command, a delta in the search 220 * pattern turns it into a first nonblank movement. 221 */ 222 nb = F_ISSET(cmdp, E_DELTA); 223 224 /* Check for the 'z' command. */ 225 if (len != 0) { 226 if (*cmd != 'z') 227 goto err1; 228 229 /* No blanks, just like the z command. */ 230 for (t = cmd + 1, tlen = len - 1; tlen > 0; ++t, --tlen) 231 if (!isdigit(*t)) 232 break; 233 if (tlen && 234 (*t == '-' || *t == '.' || *t == '+' || *t == '^')) { 235 ++t; 236 --tlen; 237 type = 1; 238 } else 239 type = 0; 240 if (tlen) 241 goto err1; 242 243 /* The z command will do the nonblank for us. */ 244 nb = 0; 245 246 /* Default to z+. */ 247 if (!type && 248 v_event_push(sp, NULL, "+", 1, CH_NOMAP | CH_QUOTED)) 249 return (1); 250 251 /* Push the user's command. */ 252 if (v_event_push(sp, NULL, cmd, len, CH_NOMAP | CH_QUOTED)) 253 return (1); 254 255 /* Push line number so get correct z display. */ 256 tlen = snprintf(buf, 257 sizeof(buf), "%lu", (u_long)vp->m_stop.lno); 258 if (v_event_push(sp, NULL, buf, tlen, CH_NOMAP | CH_QUOTED)) 259 return (1); 260 261 /* Don't refresh until after 'z' happens. */ 262 F_SET(VIP(sp), VIP_S_REFRESH); 263 } 264 265 /* Non-motion commands move to the end of the range. */ 266 vp->m_final = vp->m_stop; 267 if (nb) { 268 F_CLR(vp, VM_RCM_MASK); 269 F_SET(vp, VM_RCM_SETFNB); 270 } 271 return (0); 272 273 err1: msgq(sp, M_ERR, 274 "188|Characters after search string, line offset and/or z command"); 275 err2: vp->m_final.lno = s_lno; 276 vp->m_final.cno = s_cno; 277 return (1); 278 } 279 280 /* 281 * v_searchN -- N 282 * Reverse last search. 283 * 284 * PUBLIC: int v_searchN __P((SCR *, VICMD *)); 285 */ 286 int 287 v_searchN(sp, vp) 288 SCR *sp; 289 VICMD *vp; 290 { 291 dir_t dir; 292 293 switch (sp->searchdir) { 294 case BACKWARD: 295 dir = FORWARD; 296 break; 297 case FORWARD: 298 dir = BACKWARD; 299 break; 300 default: 301 dir = sp->searchdir; 302 break; 303 } 304 return (v_search(sp, vp, NULL, 0, SEARCH_PARSE, dir)); 305 } 306 307 /* 308 * v_searchn -- n 309 * Repeat last search. 310 * 311 * PUBLIC: int v_searchn __P((SCR *, VICMD *)); 312 */ 313 int 314 v_searchn(sp, vp) 315 SCR *sp; 316 VICMD *vp; 317 { 318 return (v_search(sp, vp, NULL, 0, SEARCH_PARSE, sp->searchdir)); 319 } 320 321 /* 322 * v_searchw -- [count]^A 323 * Search for the word under the cursor. 324 * 325 * PUBLIC: int v_searchw __P((SCR *, VICMD *)); 326 */ 327 int 328 v_searchw(sp, vp) 329 SCR *sp; 330 VICMD *vp; 331 { 332 size_t blen, len; 333 int rval; 334 char *bp; 335 336 len = VIP(sp)->klen + sizeof(RE_WSTART) + sizeof(RE_WSTOP); 337 GET_SPACE_RET(sp, bp, blen, len); 338 len = snprintf(bp, blen, "%s%s%s", RE_WSTART, VIP(sp)->keyw, RE_WSTOP); 339 340 rval = v_search(sp, vp, bp, len, SEARCH_SET, FORWARD); 341 342 FREE_SPACE(sp, bp, blen); 343 return (rval); 344 } 345 346 /* 347 * v_search -- 348 * The search commands. 349 */ 350 static int 351 v_search(sp, vp, ptrn, plen, flags, dir) 352 SCR *sp; 353 VICMD *vp; 354 u_int flags; 355 char *ptrn; 356 size_t plen; 357 dir_t dir; 358 { 359 /* Display messages. */ 360 LF_SET(SEARCH_MSG); 361 362 /* If it's a motion search, offset past end-of-line is okay. */ 363 if (ISMOTION(vp)) 364 LF_SET(SEARCH_EOL); 365 366 /* 367 * XXX 368 * Warn if the search wraps. See the comment above, in v_exaddr(). 369 */ 370 if (!KEYS_WAITING(sp)) 371 LF_SET(SEARCH_WMSG); 372 373 switch (dir) { 374 case BACKWARD: 375 if (b_search(sp, 376 &vp->m_start, &vp->m_stop, ptrn, plen, NULL, flags)) 377 return (1); 378 break; 379 case FORWARD: 380 if (f_search(sp, 381 &vp->m_start, &vp->m_stop, ptrn, plen, NULL, flags)) 382 return (1); 383 break; 384 case NOTSET: 385 msgq(sp, M_ERR, "189|No previous search pattern"); 386 return (1); 387 default: 388 abort(); 389 } 390 391 /* Correct motion commands, otherwise, simply move to the location. */ 392 if (ISMOTION(vp)) { 393 if (v_correct(sp, vp, 0)) 394 return(1); 395 } else 396 vp->m_final = vp->m_stop; 397 return (0); 398 } 399 400 /* 401 * v_correct -- 402 * Handle command with a search as the motion. 403 * 404 * !!! 405 * Historically, commands didn't affect the line searched to/from if the 406 * motion command was a search and the final position was the start/end 407 * of the line. There were some special cases and vi was not consistent; 408 * it was fairly easy to confuse it. For example, given the two lines: 409 * 410 * abcdefghi 411 * ABCDEFGHI 412 * 413 * placing the cursor on the 'A' and doing y?$ would so confuse it that 'h' 414 * 'k' and put would no longer work correctly. In any case, we try to do 415 * the right thing, but it's not going to exactly match historic practice. 416 * 417 * PUBLIC: int v_correct __P((SCR *, VICMD *, int)); 418 */ 419 int 420 v_correct(sp, vp, isdelta) 421 SCR *sp; 422 VICMD *vp; 423 int isdelta; 424 { 425 dir_t dir; 426 MARK m; 427 size_t len; 428 429 /* 430 * !!! 431 * We may have wrapped if wrapscan was set, and we may have returned 432 * to the position where the cursor started. Historic vi didn't cope 433 * with this well. Yank wouldn't beep, but the first put after the 434 * yank would move the cursor right one column (without adding any 435 * text) and the second would put a copy of the current line. The 436 * change and delete commands would beep, but would leave the cursor 437 * on the colon command line. I believe that there are macros that 438 * depend on delete, at least, failing. For now, commands that use 439 * search as a motion component fail when the search returns to the 440 * original cursor position. 441 */ 442 if (vp->m_start.lno == vp->m_stop.lno && 443 vp->m_start.cno == vp->m_stop.cno) { 444 msgq(sp, M_BERR, "190|Search wrapped to original position"); 445 return (1); 446 } 447 448 /* 449 * !!! 450 * Searches become line mode operations if there was a delta specified 451 * to the search pattern. 452 */ 453 if (isdelta) 454 F_SET(vp, VM_LMODE); 455 456 /* 457 * If the motion is in the reverse direction, switch the start and 458 * stop MARK's so that it's in a forward direction. (There's no 459 * reason for this other than to make the tests below easier. The 460 * code in vi.c:vi() would have done the switch.) Both forward 461 * and backward motions can happen for any kind of search command 462 * because of the wrapscan option. 463 */ 464 if (vp->m_start.lno > vp->m_stop.lno || 465 vp->m_start.lno == vp->m_stop.lno && 466 vp->m_start.cno > vp->m_stop.cno) { 467 m = vp->m_start; 468 vp->m_start = vp->m_stop; 469 vp->m_stop = m; 470 dir = BACKWARD; 471 } else 472 dir = FORWARD; 473 474 /* 475 * BACKWARD: 476 * Delete and yank commands move to the end of the range. 477 * Ignore others. 478 * 479 * FORWARD: 480 * Delete and yank commands don't move. Ignore others. 481 */ 482 vp->m_final = vp->m_start; 483 484 /* 485 * !!! 486 * Delta'd searches don't correct based on column positions. 487 */ 488 if (isdelta) 489 return (0); 490 491 /* 492 * !!! 493 * Backward searches starting at column 0, and forward searches ending 494 * at column 0 are corrected to the last column of the previous line. 495 * Otherwise, adjust the starting/ending point to the character before 496 * the current one (this is safe because we know the search had to move 497 * to succeed). 498 * 499 * Searches become line mode operations if they start at the first 500 * nonblank and end at column 0 of another line. 501 */ 502 if (vp->m_start.lno < vp->m_stop.lno && vp->m_stop.cno == 0) { 503 if (db_get(sp, --vp->m_stop.lno, DBG_FATAL, NULL, &len)) 504 return (1); 505 vp->m_stop.cno = len ? len - 1 : 0; 506 len = 0; 507 if (nonblank(sp, vp->m_start.lno, &len)) 508 return (1); 509 if (vp->m_start.cno <= len) 510 F_SET(vp, VM_LMODE); 511 } else 512 --vp->m_stop.cno; 513 514 return (0); 515 } 516