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