vi/v_search.c

   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[] = "$Id: v_search.c,v 10.29 2001/06/25 15:19:35 skimo Exp $ (Berkeley) $Date: 2001/06/25 15:19:35 $";
  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 #include "../ipc/ip.h"
  31
  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));
  34
  35 /*
  36  * v_srch -- [count]?RE[? offset]
  37  *      Ex address search backward.
  38  *
  39  * PUBLIC: int v_searchb __P((SCR *, VICMD *));
  40  */
  41 int
  42 v_searchb(SCR *sp, VICMD *vp)
  43 {
  44         return (v_exaddr(sp, vp, BACKWARD));
  45 }
  46
  47 /*
  48  * v_searchf -- [count]/RE[/ offset]
  49  *      Ex address search forward.
  50  *
  51  * PUBLIC: int v_searchf __P((SCR *, VICMD *));
  52  */
  53 int
  54 v_searchf(SCR *sp, VICMD *vp)
  55 {
  56         return (v_exaddr(sp, vp, FORWARD));
  57 }
  58
  59 /*
  60  * v_exaddr --
  61  *      Do a vi search (which is really an ex address).
  62  */
  63 static int
  64 v_exaddr(SCR *sp, VICMD *vp, dir_t dir)
  65 {
  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;
  77
  78         /*
  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/.
  82          */
  83         if (F_ISSET(vp, VC_ISDOT))
  84                 return (v_search(sp, vp,
  85                     NULL, 0, SEARCH_PARSE | SEARCH_MSG | SEARCH_SET, dir));
  86
  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);
  92
  93         tp = sp->tiq.cqh_first;
  94
  95         /* If the user backspaced over the prompt, do nothing. */
  96         if (tp->term == TERM_BS)
  97                 return (1);
  98
  99         /*
 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.
 103          */
 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);
 111         }
 112
 113         /*
 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.
 117          *
 118          * Build a fake ex command structure.
 119          */
 120         wp = sp->wp;
 121         wp->excmd.cp = tp->lb;
 122         wp->excmd.clen = tp->len;
 123         F_INIT(&wp->excmd, E_VISEARCH);
 124
 125         /*
 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:
 135          *
 136          *      :map K /pattern/^MjK
 137          *
 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.
 143          */
 144         if (!KEYS_WAITING(sp))
 145                 F_SET(&wp->excmd, E_SEARCH_WMSG);
 146
 147         /* Save the current line/column. */
 148         s_lno = sp->lno;
 149         s_cno = sp->cno;
 150
 151         /*
 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...
 164          *
 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.
 170          *
 171          * !!!
 172          * Historically, the command "/STRING/;   " failed, apparently it
 173          * confused the parser.  We're not that compatible.
 174          */
 175         cmdp = &wp->excmd;
 176         if (ex_range(sp, cmdp, &err))
 177                 return (1);
 178
 179         /*
 180          * Remember where any remaining command information is, and clean
 181          * up the fake ex command.
 182          */
 183         cmd = cmdp->cp;
 184         len = cmdp->clen;
 185         wp->excmd.clen = 0;
 186
 187         if (err)
 188                 goto err2;
 189
 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;
 198         }
 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;
 203         }
 204
 205         /*
 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.
 210          */
 211         if (ISMOTION(vp))
 212                 return (v_correct(sp, vp, F_ISSET(cmdp, E_DELTA)));
 213
 214         /*
 215          * !!!
 216          * Historically, if it wasn't a motion command, a delta in the search
 217          * pattern turns it into a first nonblank movement.
 218          */
 219         nb = F_ISSET(cmdp, E_DELTA);
 220
 221         /* Check for the 'z' command. */
 222         if (len != 0) {
 223                 if (*cmd != 'z')
 224                         goto err1;
 225
 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;
 239
 240                 /* The z command will do the nonblank for us. */
 241                 nb = 0;
 242
 243                 /* Default to z+. */
 244                 if (!type &&
 245                     v_event_push(sp, NULL, L("+"), 1, CH_NOMAP | CH_QUOTED))
 246                         return (1);
 247
 248                 /* Push the user's command. */
 249                 if (v_event_push(sp, NULL, cmd, len, CH_NOMAP | CH_QUOTED))
 250                         return (1);
 251
 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);
 258
 259                 /* Don't refresh until after 'z' happens. */
 260                 F_SET(VIP(sp), VIP_S_REFRESH);
 261         }
 262
 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);
 268         }
 269         return (0);
 270
 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);
 276 }
 277
 278 /*
 279  * v_searchN -- N
 280  *      Reverse last search.
 281  *
 282  * PUBLIC: int v_searchN __P((SCR *, VICMD *));
 283  */
 284 int
 285 v_searchN(SCR *sp, VICMD *vp)
 286 {
 287         dir_t dir;
 288
 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;
 299         }
 300         return (v_search(sp, vp, NULL, 0, SEARCH_PARSE, dir));
 301 }
 302
 303 /*
 304  * v_searchn -- n
 305  *      Repeat last search.
 306  *
 307  * PUBLIC: int v_searchn __P((SCR *, VICMD *));
 308  */
 309 int
 310 v_searchn(SCR *sp, VICMD *vp)
 311 {
 312         return (v_search(sp, vp, NULL, 0, SEARCH_PARSE, sp->searchdir));
 313 }
 314
 315 /*
 316  * v_searchw -- [count]^A
 317  *      Search for the word under the cursor.
 318  *
 319  * PUBLIC: int v_searchw __P((SCR *, VICMD *));
 320  */
 321 int
 322 v_searchw(SCR *sp, VICMD *vp)
 323 {
 324         size_t blen, len;
 325         int rval;
 326         CHAR_T *bp, *p;
 327
 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 + sizeof(RE_WSTART)/sizeof(CHAR_T) - 1;
 332         MEMCPY(p, VIP(sp)->keyw, VIP(sp)->klen);
 333         p += VIP(sp)->klen;
 334         MEMCPY(bp, RE_WSTOP, RE_WSTOP_LEN);
 335
 336         rval = v_search(sp, vp, bp, len, SEARCH_SET, FORWARD);
 337
 338         FREE_SPACEW(sp, bp, blen);
 339         return (rval);
 340 }
 341
 342 /*
 343  * v_esearch -- <dialog box>
 344  *      Search command from the screen.
 345  *
 346  * PUBLIC: int v_esearch __P((SCR *, VICMD *));
 347  */
 348 int
 349 v_esearch(SCR *sp, VICMD *vp)
 350 {
 351         MARK m;
 352         int flags;
 353
 354         m.lno = sp->lno;
 355         m.cno = sp->cno;
 356
 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));
 372 }
 373
 374 /*
 375  * v_search --
 376  *      The search commands.
 377  */
 378 static int
 379 v_search(SCR *sp, VICMD *vp, CHAR_T *ptrn, size_t plen, u_int flags, dir_t dir)
 380 {
 381         /* Display messages. */
 382         LF_SET(SEARCH_MSG);
 383
 384         /* If it's a motion search, offset past end-of-line is okay. */
 385         if (ISMOTION(vp))
 386                 LF_SET(SEARCH_EOL);
 387
 388         /*
 389          * XXX
 390          * Warn if the search wraps.  See the comment above, in v_exaddr().
 391          */
 392         if (!KEYS_WAITING(sp))
 393                 LF_SET(SEARCH_WMSG);
 394
 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();
 411         }
 412
 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);
 420 }
 421
 422 /*
 423  * v_correct --
 424  *      Handle command with a search as the motion.
 425  *
 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:
 431  *
 432  *      abcdefghi
 433  *      ABCDEFGHI
 434  *
 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.
 438  *
 439  * PUBLIC: int v_correct __P((SCR *, VICMD *, int));
 440  */
 441 int
 442 v_correct(SCR *sp, VICMD *vp, int isdelta)
 443 {
 444         dir_t dir;
 445         MARK m;
 446         size_t len;
 447
 448         /*
 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.
 460          */
 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);
 465         }
 466
 467         /*
 468          * !!!
 469          * Searches become line mode operations if there was a delta specified
 470          * to the search pattern.
 471          */
 472         if (isdelta)
 473                 F_SET(vp, VM_LMODE);
 474
 475         /*
 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.
 482          */
 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;
 492
 493         /*
 494          * BACKWARD:
 495          *      Delete and yank commands move to the end of the range.
 496          *      Ignore others.
 497          *
 498          * FORWARD:
 499          *      Delete and yank commands don't move.  Ignore others.
 500          */
 501         vp->m_final = vp->m_start;
 502
 503         /*
 504          * !!!
 505          * Delta'd searches don't correct based on column positions.
 506          */
 507         if (isdelta)
 508                 return (0);
 509
 510         /*
 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).
 517          *
 518          * Searches become line mode operations if they start at the first
 519          * nonblank and end at column 0 of another line.
 520          */
 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;
 532
 533         return (0);
 534 }