contrib/nvi/ex/ex_subst.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[] = "@(#)ex_subst.c    10.37 (Berkeley) 9/15/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 #include <unistd.h>
  28
  29 #include "../common/common.h"
  30 #include "../vi/vi.h"
  31
  32 #define SUB_FIRST       0x01            /* The 'r' flag isn't reasonable. */
  33 #define SUB_MUSTSETR    0x02            /* The 'r' flag is required. */
  34
  35 static int re_conv __P((SCR *, char **, size_t *, int *));
  36 static int re_cscope_conv __P((SCR *, char **, size_t *, int *));
  37 static int re_sub __P((SCR *,
  38                 char *, char **, size_t *, size_t *, regmatch_t [10]));
  39 static int re_tag_conv __P((SCR *, char **, size_t *, int *));
  40 static int s __P((SCR *, EXCMD *, char *, regex_t *, u_int));
  41
  42 /*
  43  * ex_s --
  44  *      [line [,line]] s[ubstitute] [[/;]pat[/;]/repl[/;] [cgr] [count] [#lp]]
  45  *
  46  *      Substitute on lines matching a pattern.
  47  *
  48  * PUBLIC: int ex_s __P((SCR *, EXCMD *));
  49  */
  50 int
  51 ex_s(sp, cmdp)
  52         SCR *sp;
  53         EXCMD *cmdp;
  54 {
  55         regex_t *re;
  56         size_t blen, len;
  57         u_int flags;
  58         int delim;
  59         char *bp, *ptrn, *rep, *p, *t;
  60
  61         /*
  62          * Skip leading white space.
  63          *
  64          * !!!
  65          * Historic vi allowed any non-alphanumeric to serve as the
  66          * substitution command delimiter.
  67          *
  68          * !!!
  69          * If the arguments are empty, it's the same as &, i.e. we
  70          * repeat the last substitution.
  71          */
  72         if (cmdp->argc == 0)
  73                 goto subagain;
  74         for (p = cmdp->argv[0]->bp,
  75             len = cmdp->argv[0]->len; len > 0; --len, ++p) {
  76                 if (!isblank(*p))
  77                         break;
  78         }
  79         if (len == 0)
  80 subagain:       return (ex_subagain(sp, cmdp));
  81
  82         delim = *p++;
  83         if (isalnum(delim) || delim == '\\')
  84                 return (s(sp, cmdp, p, &sp->subre_c, SUB_MUSTSETR));
  85
  86         /*
  87          * !!!
  88          * The full-blown substitute command reset the remembered
  89          * state of the 'c' and 'g' suffices.
  90          */
  91         sp->c_suffix = sp->g_suffix = 0;
  92
  93         /*
  94          * Get the pattern string, toss escaping characters.
  95          *
  96          * !!!
  97          * Historic vi accepted any of the following forms:
  98          *
  99          *      :s/abc/def/             change "abc" to "def"
 100          *      :s/abc/def              change "abc" to "def"
 101          *      :s/abc/                 delete "abc"
 102          *      :s/abc                  delete "abc"
 103          *
 104          * QUOTING NOTE:
 105          *
 106          * Only toss an escaping character if it escapes a delimiter.
 107          * This means that "s/A/\\\\f" replaces "A" with "\\f".  It
 108          * would be nice to be more regular, i.e. for each layer of
 109          * escaping a single escaping character is removed, but that's
 110          * not how the historic vi worked.
 111          */
 112         for (ptrn = t = p;;) {
 113                 if (p[0] == '\0' || p[0] == delim) {
 114                         if (p[0] == delim)
 115                                 ++p;
 116                         /*
 117                          * !!!
 118                          * Nul terminate the pattern string -- it's passed
 119                          * to regcomp which doesn't understand anything else.
 120                          */
 121                         *t = '\0';
 122                         break;
 123                 }
 124                 if (p[0] == '\\')
 125                         if (p[1] == delim)
 126                                 ++p;
 127                         else if (p[1] == '\\')
 128                                 *t++ = *p++;
 129                 *t++ = *p++;
 130         }
 131
 132         /*
 133          * If the pattern string is empty, use the last RE (not just the
 134          * last substitution RE).
 135          */
 136         if (*ptrn == '\0') {
 137                 if (sp->re == NULL) {
 138                         ex_emsg(sp, NULL, EXM_NOPREVRE);
 139                         return (1);
 140                 }
 141
 142                 /* Re-compile the RE if necessary. */
 143                 if (!F_ISSET(sp, SC_RE_SEARCH) && re_compile(sp,
 144                     sp->re, sp->re_len, NULL, NULL, &sp->re_c, RE_C_SEARCH))
 145                         return (1);
 146                 flags = 0;
 147         } else {
 148                 /*
 149                  * !!!
 150                  * Compile the RE.  Historic practice is that substitutes set
 151                  * the search direction as well as both substitute and search
 152                  * RE's.  We compile the RE twice, as we don't want to bother
 153                  * ref counting the pattern string and (opaque) structure.
 154                  */
 155                 if (re_compile(sp, ptrn, t - ptrn,
 156                     &sp->re, &sp->re_len, &sp->re_c, RE_C_SEARCH))
 157                         return (1);
 158                 if (re_compile(sp, ptrn, t - ptrn,
 159                     &sp->subre, &sp->subre_len, &sp->subre_c, RE_C_SUBST))
 160                         return (1);
 161
 162                 flags = SUB_FIRST;
 163                 sp->searchdir = FORWARD;
 164         }
 165         re = &sp->re_c;
 166
 167         /*
 168          * Get the replacement string.
 169          *
 170          * The special character & (\& if O_MAGIC not set) matches the
 171          * entire RE.  No handling of & is required here, it's done by
 172          * re_sub().
 173          *
 174          * The special character ~ (\~ if O_MAGIC not set) inserts the
 175          * previous replacement string into this replacement string.
 176          * Count ~'s to figure out how much space we need.  We could
 177          * special case nonexistent last patterns or whether or not
 178          * O_MAGIC is set, but it's probably not worth the effort.
 179          *
 180          * QUOTING NOTE:
 181          *
 182          * Only toss an escaping character if it escapes a delimiter or
 183          * if O_MAGIC is set and it escapes a tilde.
 184          *
 185          * !!!
 186          * If the entire replacement pattern is "%", then use the last
 187          * replacement pattern.  This semantic was added to vi in System
 188          * V and then percolated elsewhere, presumably around the time
 189          * that it was added to their version of ed(1).
 190          */
 191         if (p[0] == '\0' || p[0] == delim) {
 192                 if (p[0] == delim)
 193                         ++p;
 194                 if (sp->repl != NULL)
 195                         free(sp->repl);
 196                 sp->repl = NULL;
 197                 sp->repl_len = 0;
 198         } else if (p[0] == '%' && (p[1] == '\0' || p[1] == delim))
 199                 p += p[1] == delim ? 2 : 1;
 200         else {
 201                 for (rep = p, len = 0;
 202                     p[0] != '\0' && p[0] != delim; ++p, ++len)
 203                         if (p[0] == '~')
 204                                 len += sp->repl_len;
 205                 GET_SPACE_RET(sp, bp, blen, len);
 206                 for (t = bp, len = 0, p = rep;;) {
 207                         if (p[0] == '\0' || p[0] == delim) {
 208                                 if (p[0] == delim)
 209                                         ++p;
 210                                 break;
 211                         }
 212                         if (p[0] == '\\') {
 213                                 if (p[1] == delim)
 214                                         ++p;
 215                                 else if (p[1] == '\\') {
 216                                         *t++ = *p++;
 217                                         ++len;
 218                                 } else if (p[1] == '~') {
 219                                         ++p;
 220                                         if (!O_ISSET(sp, O_MAGIC))
 221                                                 goto tilde;
 222                                 }
 223                         } else if (p[0] == '~' && O_ISSET(sp, O_MAGIC)) {
 224 tilde:                          ++p;
 225                                 memcpy(t, sp->repl, sp->repl_len);
 226                                 t += sp->repl_len;
 227                                 len += sp->repl_len;
 228                                 continue;
 229                         }
 230                         *t++ = *p++;
 231                         ++len;
 232                 }
 233                 if ((sp->repl_len = len) != 0) {
 234                         if (sp->repl != NULL)
 235                                 free(sp->repl);
 236                         if ((sp->repl = malloc(len)) == NULL) {
 237                                 msgq(sp, M_SYSERR, NULL);
 238                                 FREE_SPACE(sp, bp, blen);
 239                                 return (1);
 240                         }
 241                         memcpy(sp->repl, bp, len);
 242                 }
 243                 FREE_SPACE(sp, bp, blen);
 244         }
 245         return (s(sp, cmdp, p, re, flags));
 246 }
 247
 248 /*
 249  * ex_subagain --
 250  *      [line [,line]] & [cgr] [count] [#lp]]
 251  *
 252  *      Substitute using the last substitute RE and replacement pattern.
 253  *
 254  * PUBLIC: int ex_subagain __P((SCR *, EXCMD *));
 255  */
 256 int
 257 ex_subagain(sp, cmdp)
 258         SCR *sp;
 259         EXCMD *cmdp;
 260 {
 261         if (sp->subre == NULL) {
 262                 ex_emsg(sp, NULL, EXM_NOPREVRE);
 263                 return (1);
 264         }
 265         if (!F_ISSET(sp, SC_RE_SUBST) && re_compile(sp,
 266             sp->subre, sp->subre_len, NULL, NULL, &sp->subre_c, RE_C_SUBST))
 267                 return (1);
 268         return (s(sp,
 269             cmdp, cmdp->argc ? cmdp->argv[0]->bp : NULL, &sp->subre_c, 0));
 270 }
 271
 272 /*
 273  * ex_subtilde --
 274  *      [line [,line]] ~ [cgr] [count] [#lp]]
 275  *
 276  *      Substitute using the last RE and last substitute replacement pattern.
 277  *
 278  * PUBLIC: int ex_subtilde __P((SCR *, EXCMD *));
 279  */
 280 int
 281 ex_subtilde(sp, cmdp)
 282         SCR *sp;
 283         EXCMD *cmdp;
 284 {
 285         if (sp->re == NULL) {
 286                 ex_emsg(sp, NULL, EXM_NOPREVRE);
 287                 return (1);
 288         }
 289         if (!F_ISSET(sp, SC_RE_SEARCH) && re_compile(sp,
 290             sp->re, sp->re_len, NULL, NULL, &sp->re_c, RE_C_SEARCH))
 291                 return (1);
 292         return (s(sp,
 293             cmdp, cmdp->argc ? cmdp->argv[0]->bp : NULL, &sp->re_c, 0));
 294 }
 295
 296 /*
 297  * s --
 298  * Do the substitution.  This stuff is *really* tricky.  There are lots of
 299  * special cases, and general nastiness.  Don't mess with it unless you're
 300  * pretty confident.
 301  *
 302  * The nasty part of the substitution is what happens when the replacement
 303  * string contains newlines.  It's a bit tricky -- consider the information
 304  * that has to be retained for "s/f\(o\)o/^M\1^M\1/".  The solution here is
 305  * to build a set of newline offsets which we use to break the line up later,
 306  * when the replacement is done.  Don't change it unless you're *damned*
 307  * confident.
 308  */
 309 #define NEEDNEWLINE(sp) {                                               \
 310         if (sp->newl_len == sp->newl_cnt) {                             \
 311                 sp->newl_len += 25;                                     \
 312                 REALLOC(sp, sp->newl, size_t *,                         \
 313                     sp->newl_len * sizeof(size_t));                     \
 314                 if (sp->newl == NULL) {                                 \
 315                         sp->newl_len = 0;                               \
 316                         return (1);                                     \
 317                 }                                                       \
 318         }                                                               \
 319 }
 320
 321 #define BUILD(sp, l, len) {                                             \
 322         if (lbclen + (len) > lblen) {                                   \
 323                 lblen += MAX(lbclen + (len), 256);                      \
 324                 REALLOC(sp, lb, char *, lblen);                         \
 325                 if (lb == NULL) {                                       \
 326                         lbclen = 0;                                     \
 327                         return (1);                                     \
 328                 }                                                       \
 329         }                                                               \
 330         memcpy(lb + lbclen, l, len);                                    \
 331         lbclen += len;                                                  \
 332 }
 333
 334 #define NEEDSP(sp, len, pnt) {                                          \
 335         if (lbclen + (len) > lblen) {                                   \
 336                 lblen += MAX(lbclen + (len), 256);                      \
 337                 REALLOC(sp, lb, char *, lblen);                         \
 338                 if (lb == NULL) {                                       \
 339                         lbclen = 0;                                     \
 340                         return (1);                                     \
 341                 }                                                       \
 342                 pnt = lb + lbclen;                                      \
 343         }                                                               \
 344 }
 345
 346 static int
 347 s(sp, cmdp, s, re, flags)
 348         SCR *sp;
 349         EXCMD *cmdp;
 350         char *s;
 351         regex_t *re;
 352         u_int flags;
 353 {
 354         EVENT ev;
 355         MARK from, to;
 356         TEXTH tiq;
 357         recno_t elno, lno, slno;
 358         regmatch_t match[10];
 359         size_t blen, cnt, last, lbclen, lblen, len, llen;
 360         size_t offset, saved_offset, scno;
 361         int cflag, lflag, nflag, pflag, rflag;
 362         int didsub, do_eol_match, eflags, empty_ok, eval;
 363         int linechanged, matched, quit, rval;
 364         char *bp, *lb;
 365
 366         NEEDFILE(sp, cmdp);
 367
 368         slno = sp->lno;
 369         scno = sp->cno;
 370
 371         /*
 372          * !!!
 373          * Historically, the 'g' and 'c' suffices were always toggled as flags,
 374          * so ":s/A/B/" was the same as ":s/A/B/ccgg".  If O_EDCOMPATIBLE was
 375          * not set, they were initialized to 0 for all substitute commands.  If
 376          * O_EDCOMPATIBLE was set, they were initialized to 0 only if the user
 377          * specified substitute/replacement patterns (see ex_s()).
 378          */
 379         if (!O_ISSET(sp, O_EDCOMPATIBLE))
 380                 sp->c_suffix = sp->g_suffix = 0;
 381
 382         /*
 383          * Historic vi permitted the '#', 'l' and 'p' options in vi mode, but
 384          * it only displayed the last change.  I'd disallow them, but they are
 385          * useful in combination with the [v]global commands.  In the current
 386          * model the problem is combining them with the 'c' flag -- the screen
 387          * would have to flip back and forth between the confirm screen and the
 388          * ex print screen, which would be pretty awful.  We do display all
 389          * changes, though, for what that's worth.
 390          *
 391          * !!!
 392          * Historic vi was fairly strict about the order of "options", the
 393          * count, and "flags".  I'm somewhat fuzzy on the difference between
 394          * options and flags, anyway, so this is a simpler approach, and we
 395          * just take it them in whatever order the user gives them.  (The ex
 396          * usage statement doesn't reflect this.)
 397          */
 398         cflag = lflag = nflag = pflag = rflag = 0;
 399         if (s == NULL)
 400                 goto noargs;
 401         for (lno = OOBLNO; *s != '\0'; ++s)
 402                 switch (*s) {
 403                 case ' ':
 404                 case '\t':
 405                         continue;
 406                 case '+':
 407                         ++cmdp->flagoff;
 408                         break;
 409                 case '-':
 410                         --cmdp->flagoff;
 411                         break;
 412                 case '0': case '1': case '2': case '3': case '4':
 413                 case '5': case '6': case '7': case '8': case '9':
 414                         if (lno != OOBLNO)
 415                                 goto usage;
 416                         errno = 0;
 417                         lno = strtoul(s, &s, 10);
 418                         if (*s == '\0')         /* Loop increment correction. */
 419                                 --s;
 420                         if (errno == ERANGE) {
 421                                 if (lno == LONG_MAX)
 422                                         msgq(sp, M_ERR, "153|Count overflow");
 423                                 else if (lno == LONG_MIN)
 424                                         msgq(sp, M_ERR, "154|Count underflow");
 425                                 else
 426                                         msgq(sp, M_SYSERR, NULL);
 427                                 return (1);
 428                         }
 429                         /*
 430                          * In historic vi, the count was inclusive from the
 431                          * second address.
 432                          */
 433                         cmdp->addr1.lno = cmdp->addr2.lno;
 434                         cmdp->addr2.lno += lno - 1;
 435                         if (!db_exist(sp, cmdp->addr2.lno) &&
 436                             db_last(sp, &cmdp->addr2.lno))
 437                                 return (1);
 438                         break;
 439                 case '#':
 440                         nflag = 1;
 441                         break;
 442                 case 'c':
 443                         sp->c_suffix = !sp->c_suffix;
 444
 445                         /* Ex text structure initialization. */
 446                         if (F_ISSET(sp, SC_EX)) {
 447                                 memset(&tiq, 0, sizeof(TEXTH));
 448                                 CIRCLEQ_INIT(&tiq);
 449                         }
 450                         break;
 451                 case 'g':
 452                         sp->g_suffix = !sp->g_suffix;
 453                         break;
 454                 case 'l':
 455                         lflag = 1;
 456                         break;
 457                 case 'p':
 458                         pflag = 1;
 459                         break;
 460                 case 'r':
 461                         if (LF_ISSET(SUB_FIRST)) {
 462                                 msgq(sp, M_ERR,
 463                     "155|Regular expression specified; r flag meaningless");
 464                                 return (1);
 465                         }
 466                         if (!F_ISSET(sp, SC_RE_SEARCH)) {
 467                                 ex_emsg(sp, NULL, EXM_NOPREVRE);
 468                                 return (1);
 469                         }
 470                         rflag = 1;
 471                         re = &sp->re_c;
 472                         break;
 473                 default:
 474                         goto usage;
 475                 }
 476
 477         if (*s != '\0' || !rflag && LF_ISSET(SUB_MUSTSETR)) {
 478 usage:          ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
 479                 return (1);
 480         }
 481
 482 noargs: if (F_ISSET(sp, SC_VI) && sp->c_suffix && (lflag || nflag || pflag)) {
 483                 msgq(sp, M_ERR,
 484 "156|The #, l and p flags may not be combined with the c flag in vi mode");
 485                 return (1);
 486         }
 487
 488         /*
 489          * bp:          if interactive, line cache
 490          * blen:        if interactive, line cache length
 491          * lb:          build buffer pointer.
 492          * lbclen:      current length of built buffer.
 493          * lblen;       length of build buffer.
 494          */
 495         bp = lb = NULL;
 496         blen = lbclen = lblen = 0;
 497
 498         /* For each line... */
 499         for (matched = quit = 0, lno = cmdp->addr1.lno,
 500             elno = cmdp->addr2.lno; !quit && lno <= elno; ++lno) {
 501
 502                 /* Someone's unhappy, time to stop. */
 503                 if (INTERRUPTED(sp))
 504                         break;
 505
 506                 /* Get the line. */
 507                 if (db_get(sp, lno, DBG_FATAL, &s, &llen))
 508                         goto err;
 509
 510                 /*
 511                  * Make a local copy if doing confirmation -- when calling
 512                  * the confirm routine we're likely to lose the cached copy.
 513                  */
 514                 if (sp->c_suffix) {
 515                         if (bp == NULL) {
 516                                 GET_SPACE_RET(sp, bp, blen, llen);
 517                         } else
 518                                 ADD_SPACE_RET(sp, bp, blen, llen);
 519                         memcpy(bp, s, llen);
 520                         s = bp;
 521                 }
 522
 523                 /* Start searching from the beginning. */
 524                 offset = 0;
 525                 len = llen;
 526
 527                 /* Reset the build buffer offset. */
 528                 lbclen = 0;
 529
 530                 /* Reset empty match flag. */
 531                 empty_ok = 1;
 532
 533                 /*
 534                  * We don't want to have to do a setline if the line didn't
 535                  * change -- keep track of whether or not this line changed.
 536                  * If doing confirmations, don't want to keep setting the
 537                  * line if change is refused -- keep track of substitutions.
 538                  */
 539                 didsub = linechanged = 0;
 540
 541                 /* New line, do an EOL match. */
 542                 do_eol_match = 1;
 543
 544                 /* It's not nul terminated, but we pretend it is. */
 545                 eflags = REG_STARTEND;
 546
 547                 /*
 548                  * The search area is from s + offset to the EOL.
 549                  *
 550                  * Generally, match[0].rm_so is the offset of the start
 551                  * of the match from the start of the search, and offset
 552                  * is the offset of the start of the last search.
 553                  */
 554 nextmatch:      match[0].rm_so = 0;
 555                 match[0].rm_eo = len;
 556
 557                 /* Get the next match. */
 558                 eval = regexec(re, (char *)s + offset, 10, match, eflags);
 559
 560                 /*
 561                  * There wasn't a match or if there was an error, deal with
 562                  * it.  If there was a previous match in this line, resolve
 563                  * the changes into the database.  Otherwise, just move on.
 564                  */
 565                 if (eval == REG_NOMATCH)
 566                         goto endmatch;
 567                 if (eval != 0) {
 568                         re_error(sp, eval, re);
 569                         goto err;
 570                 }
 571                 matched = 1;
 572
 573                 /* Only the first search can match an anchored expression. */
 574                 eflags |= REG_NOTBOL;
 575
 576                 /*
 577                  * !!!
 578                  * It's possible to match 0-length strings -- for example, the
 579                  * command s;a*;X;, when matched against the string "aabb" will
 580                  * result in "XbXbX", i.e. the matches are "aa", the space
 581                  * between the b's and the space between the b's and the end of
 582                  * the string.  There is a similar space between the beginning
 583                  * of the string and the a's.  The rule that we use (because vi
 584                  * historically used it) is that any 0-length match, occurring
 585                  * immediately after a match, is ignored.  Otherwise, the above
 586                  * example would have resulted in "XXbXbX".  Another example is
 587                  * incorrectly using " *" to replace groups of spaces with one
 588                  * space.
 589                  *
 590                  * The way we do this is that if we just had a successful match,
 591                  * the starting offset does not skip characters, and the match
 592                  * is empty, ignore the match and move forward.  If there's no
 593                  * more characters in the string, we were attempting to match
 594                  * after the last character, so quit.
 595                  */
 596                 if (!empty_ok && match[0].rm_so == 0 && match[0].rm_eo == 0) {
 597                         empty_ok = 1;
 598                         if (len == 0)
 599                                 goto endmatch;
 600                         BUILD(sp, s + offset, 1)
 601                         ++offset;
 602                         --len;
 603                         goto nextmatch;
 604                 }
 605
 606                 /* Confirm change. */
 607                 if (sp->c_suffix) {
 608                         /*
 609                          * Set the cursor position for confirmation.  Note,
 610                          * if we matched on a '$', the cursor may be past
 611                          * the end of line.
 612                          */
 613                         from.lno = to.lno = lno;
 614                         from.cno = match[0].rm_so + offset;
 615                         to.cno = match[0].rm_eo + offset;
 616                         /*
 617                          * Both ex and vi have to correct for a change before
 618                          * the first character in the line.
 619                          */
 620                         if (llen == 0)
 621                                 from.cno = to.cno = 0;
 622                         if (F_ISSET(sp, SC_VI)) {
 623                                 /*
 624                                  * Only vi has to correct for a change after
 625                                  * the last character in the line.
 626                                  *
 627                                  * XXX
 628                                  * It would be nice to change the vi code so
 629                                  * that we could display a cursor past EOL.
 630                                  */
 631                                 if (to.cno >= llen)
 632                                         to.cno = llen - 1;
 633                                 if (from.cno >= llen)
 634                                         from.cno = llen - 1;
 635
 636                                 sp->lno = from.lno;
 637                                 sp->cno = from.cno;
 638                                 if (vs_refresh(sp, 1))
 639                                         goto err;
 640
 641                                 vs_update(sp, msg_cat(sp,
 642                                     "169|Confirm change? [n]", NULL), NULL);
 643
 644                                 if (v_event_get(sp, &ev, 0, 0))
 645                                         goto err;
 646                                 switch (ev.e_event) {
 647                                 case E_CHARACTER:
 648                                         break;
 649                                 case E_EOF:
 650                                 case E_ERR:
 651                                 case E_INTERRUPT:
 652                                         goto lquit;
 653                                 default:
 654                                         v_event_err(sp, &ev);
 655                                         goto lquit;
 656                                 }
 657                         } else {
 658                                 if (ex_print(sp, cmdp, &from, &to, 0) ||
 659                                     ex_scprint(sp, &from, &to))
 660                                         goto lquit;
 661                                 if (ex_txt(sp, &tiq, 0, TXT_CR))
 662                                         goto err;
 663                                 ev.e_c = tiq.cqh_first->lb[0];
 664                         }
 665
 666                         switch (ev.e_c) {
 667                         case CH_YES:
 668                                 break;
 669                         default:
 670                         case CH_NO:
 671                                 didsub = 0;
 672                                 BUILD(sp, s +offset, match[0].rm_eo);
 673                                 goto skip;
 674                         case CH_QUIT:
 675                                 /* Set the quit/interrupted flags. */
 676 lquit:                          quit = 1;
 677                                 F_SET(sp->gp, G_INTERRUPTED);
 678
 679                                 /*
 680                                  * Resolve any changes, then return to (and
 681                                  * exit from) the main loop.
 682                                  */
 683                                 goto endmatch;
 684                         }
 685                 }
 686
 687                 /*
 688                  * Set the cursor to the last position changed, converting
 689                  * from 1-based to 0-based.
 690                  */
 691                 sp->lno = lno;
 692                 sp->cno = match[0].rm_so;
 693
 694                 /* Copy the bytes before the match into the build buffer. */
 695                 BUILD(sp, s + offset, match[0].rm_so);
 696
 697                 /* Substitute the matching bytes. */
 698                 didsub = 1;
 699                 if (re_sub(sp, s + offset, &lb, &lbclen, &lblen, match))
 700                         goto err;
 701
 702                 /* Set the change flag so we know this line was modified. */
 703                 linechanged = 1;
 704
 705                 /* Move past the matched bytes. */
 706 skip:           offset += match[0].rm_eo;
 707                 len -= match[0].rm_eo;
 708
 709                 /* A match cannot be followed by an empty pattern. */
 710                 empty_ok = 0;
 711
 712                 /*
 713                  * If doing a global change with confirmation, we have to
 714                  * update the screen.  The basic idea is to store the line
 715                  * so the screen update routines can find it, and restart.
 716                  */
 717                 if (didsub && sp->c_suffix && sp->g_suffix) {
 718                         /*
 719                          * The new search offset will be the end of the
 720                          * modified line.
 721                          */
 722                         saved_offset = lbclen;
 723
 724                         /* Copy the rest of the line. */
 725                         if (len)
 726                                 BUILD(sp, s + offset, len)
 727
 728                         /* Set the new offset. */
 729                         offset = saved_offset;
 730
 731                         /* Store inserted lines, adjusting the build buffer. */
 732                         last = 0;
 733                         if (sp->newl_cnt) {
 734                                 for (cnt = 0;
 735                                     cnt < sp->newl_cnt; ++cnt, ++lno, ++elno) {
 736                                         if (db_insert(sp, lno,
 737                                             lb + last, sp->newl[cnt] - last))
 738                                                 goto err;
 739                                         last = sp->newl[cnt] + 1;
 740                                         ++sp->rptlines[L_ADDED];
 741                                 }
 742                                 lbclen -= last;
 743                                 offset -= last;
 744                                 sp->newl_cnt = 0;
 745                         }
 746
 747                         /* Store and retrieve the line. */
 748                         if (db_set(sp, lno, lb + last, lbclen))
 749                                 goto err;
 750                         if (db_get(sp, lno, DBG_FATAL, &s, &llen))
 751                                 goto err;
 752                         ADD_SPACE_RET(sp, bp, blen, llen)
 753                         memcpy(bp, s, llen);
 754                         s = bp;
 755                         len = llen - offset;
 756
 757                         /* Restart the build. */
 758                         lbclen = 0;
 759                         BUILD(sp, s, offset);
 760
 761                         /*
 762                          * If we haven't already done the after-the-string
 763                          * match, do one.  Set REG_NOTEOL so the '$' pattern
 764                          * only matches once.
 765                          */
 766                         if (!do_eol_match)
 767                                 goto endmatch;
 768                         if (offset == len) {
 769                                 do_eol_match = 0;
 770                                 eflags |= REG_NOTEOL;
 771                         }
 772                         goto nextmatch;
 773                 }
 774
 775                 /*
 776                  * If it's a global:
 777                  *
 778                  * If at the end of the string, do a test for the after
 779                  * the string match.  Set REG_NOTEOL so the '$' pattern
 780                  * only matches once.
 781                  */
 782                 if (sp->g_suffix && do_eol_match) {
 783                         if (len == 0) {
 784                                 do_eol_match = 0;
 785                                 eflags |= REG_NOTEOL;
 786                         }
 787                         goto nextmatch;
 788                 }
 789
 790 endmatch:       if (!linechanged)
 791                         continue;
 792
 793                 /* Copy any remaining bytes into the build buffer. */
 794                 if (len)
 795                         BUILD(sp, s + offset, len)
 796
 797                 /* Store inserted lines, adjusting the build buffer. */
 798                 last = 0;
 799                 if (sp->newl_cnt) {
 800                         for (cnt = 0;
 801                             cnt < sp->newl_cnt; ++cnt, ++lno, ++elno) {
 802                                 if (db_insert(sp,
 803                                     lno, lb + last, sp->newl[cnt] - last))
 804                                         goto err;
 805                                 last = sp->newl[cnt] + 1;
 806                                 ++sp->rptlines[L_ADDED];
 807                         }
 808                         lbclen -= last;
 809                         sp->newl_cnt = 0;
 810                 }
 811
 812                 /* Store the changed line. */
 813                 if (db_set(sp, lno, lb + last, lbclen))
 814                         goto err;
 815
 816                 /* Update changed line counter. */
 817                 if (sp->rptlchange != lno) {
 818                         sp->rptlchange = lno;
 819                         ++sp->rptlines[L_CHANGED];
 820                 }
 821
 822                 /*
 823                  * !!!
 824                  * Display as necessary.  Historic practice is to only
 825                  * display the last line of a line split into multiple
 826                  * lines.
 827                  */
 828                 if (lflag || nflag || pflag) {
 829                         from.lno = to.lno = lno;
 830                         from.cno = to.cno = 0;
 831                         if (lflag)
 832                                 (void)ex_print(sp, cmdp, &from, &to, E_C_LIST);
 833                         if (nflag)
 834                                 (void)ex_print(sp, cmdp, &from, &to, E_C_HASH);
 835                         if (pflag)
 836                                 (void)ex_print(sp, cmdp, &from, &to, E_C_PRINT);
 837                 }
 838         }
 839
 840         /*
 841          * !!!
 842          * Historically, vi attempted to leave the cursor at the same place if
 843          * the substitution was done at the current cursor position.  Otherwise
 844          * it moved it to the first non-blank of the last line changed.  There
 845          * were some problems: for example, :s/$/foo/ with the cursor on the
 846          * last character of the line left the cursor on the last character, or
 847          * the & command with multiple occurrences of the matching string in the
 848          * line usually left the cursor in a fairly random position.
 849          *
 850          * We try to do the same thing, with the exception that if the user is
 851          * doing substitution with confirmation, we move to the last line about
 852          * which the user was consulted, as opposed to the last line that they
 853          * actually changed.  This prevents a screen flash if the user doesn't
 854          * change many of the possible lines.
 855          */
 856         if (!sp->c_suffix && (sp->lno != slno || sp->cno != scno)) {
 857                 sp->cno = 0;
 858                 (void)nonblank(sp, sp->lno, &sp->cno);
 859         }
 860
 861         /*
 862          * If not in a global command, and nothing matched, say so.
 863          * Else, if none of the lines displayed, put something up.
 864          */
 865         rval = 0;
 866         if (!matched) {
 867                 if (!F_ISSET(sp, SC_EX_GLOBAL)) {
 868                         msgq(sp, M_ERR, "157|No match found");
 869                         goto err;
 870                 }
 871         } else if (!lflag && !nflag && !pflag)
 872                 F_SET(cmdp, E_AUTOPRINT);
 873
 874         if (0) {
 875 err:            rval = 1;
 876         }
 877
 878         if (bp != NULL)
 879                 FREE_SPACE(sp, bp, blen);
 880         if (lb != NULL)
 881                 free(lb);
 882         return (rval);
 883 }
 884
 885 /*
 886  * re_compile --
 887  *      Compile the RE.
 888  *
 889  * PUBLIC: int re_compile __P((SCR *,
 890  * PUBLIC:     char *, size_t, char **, size_t *, regex_t *, u_int));
 891  */
 892 int
 893 re_compile(sp, ptrn, plen, ptrnp, lenp, rep, flags)
 894         SCR *sp;
 895         char *ptrn, **ptrnp;
 896         size_t plen, *lenp;
 897         regex_t *rep;
 898         u_int flags;
 899 {
 900         size_t len;
 901         int reflags, replaced, rval;
 902         char *p;
 903
 904         /* Set RE flags. */
 905         reflags = 0;
 906         if (!LF_ISSET(RE_C_CSCOPE | RE_C_TAG)) {
 907                 if (O_ISSET(sp, O_EXTENDED))
 908                         reflags |= REG_EXTENDED;
 909                 if (O_ISSET(sp, O_IGNORECASE))
 910                         reflags |= REG_ICASE;
 911                 if (O_ISSET(sp, O_ICLOWER)) {
 912                         for (p = ptrn, len = plen; len > 0; ++p, --len)
 913                                 if (isupper(*p))
 914                                         break;
 915                         if (len == 0)
 916                                 reflags |= REG_ICASE;
 917                 }
 918         }
 919
 920         /* If we're replacing a saved value, clear the old one. */
 921         if (LF_ISSET(RE_C_SEARCH) && F_ISSET(sp, SC_RE_SEARCH)) {
 922                 regfree(&sp->re_c);
 923                 F_CLR(sp, SC_RE_SEARCH);
 924         }
 925         if (LF_ISSET(RE_C_SUBST) && F_ISSET(sp, SC_RE_SUBST)) {
 926                 regfree(&sp->subre_c);
 927                 F_CLR(sp, SC_RE_SUBST);
 928         }
 929
 930         /*
 931          * If we're saving the string, it's a pattern we haven't seen before,
 932          * so convert the vi-style RE's to POSIX 1003.2 RE's.  Save a copy for
 933          * later recompilation.   Free any previously saved value.
 934          */
 935         if (ptrnp != NULL) {
 936                 if (LF_ISSET(RE_C_CSCOPE)) {
 937                         if (re_cscope_conv(sp, &ptrn, &plen, &replaced))
 938                                 return (1);
 939                         /*
 940                          * XXX
 941                          * Currently, the match-any-<blank> expression used in
 942                          * re_cscope_conv() requires extended RE's.  This may
 943                          * not be right or safe.
 944                          */
 945                         reflags |= REG_EXTENDED;
 946                 } else if (LF_ISSET(RE_C_TAG)) {
 947                         if (re_tag_conv(sp, &ptrn, &plen, &replaced))
 948                                 return (1);
 949                 } else
 950                         if (re_conv(sp, &ptrn, &plen, &replaced))
 951                                 return (1);
 952
 953                 /* Discard previous pattern. */
 954                 if (*ptrnp != NULL) {
 955                         free(*ptrnp);
 956                         *ptrnp = NULL;
 957                 }
 958                 if (lenp != NULL)
 959                         *lenp = plen;
 960
 961                 /*
 962                  * Copy the string into allocated memory.
 963                  *
 964                  * XXX
 965                  * Regcomp isn't 8-bit clean, so the pattern is nul-terminated
 966                  * for now.  There's just no other solution.
 967                  */
 968                 MALLOC(sp, *ptrnp, char *, plen + 1);
 969                 if (*ptrnp != NULL) {
 970                         memcpy(*ptrnp, ptrn, plen);
 971                         (*ptrnp)[plen] = '\0';
 972                 }
 973
 974                 /* Free up conversion-routine-allocated memory. */
 975                 if (replaced)
 976                         FREE_SPACE(sp, ptrn, 0);
 977
 978                 if (*ptrnp == NULL)
 979                         return (1);
 980
 981                 ptrn = *ptrnp;
 982         }
 983
 984         /*
 985          * XXX
 986          * Regcomp isn't 8-bit clean, so we just lost if the pattern
 987          * contained a nul.  Bummer!
 988          */
 989         if ((rval = regcomp(rep, ptrn, /* plen, */ reflags)) != 0) {
 990                 if (!LF_ISSET(RE_C_SILENT))
 991                         re_error(sp, rval, rep);
 992                 return (1);
 993         }
 994
 995         if (LF_ISSET(RE_C_SEARCH))
 996                 F_SET(sp, SC_RE_SEARCH);
 997         if (LF_ISSET(RE_C_SUBST))
 998                 F_SET(sp, SC_RE_SUBST);
 999
1000         return (0);
1001 }
1002
1003 /*
1004  * re_conv --
1005  *      Convert vi's regular expressions into something that the
1006  *      the POSIX 1003.2 RE functions can handle.
1007  *
1008  * There are three conversions we make to make vi's RE's (specifically
1009  * the global, search, and substitute patterns) work with POSIX RE's.
1010  *
1011  * 1: If O_MAGIC is not set, strip backslashes from the magic character
1012  *    set (.[*~) that have them, and add them to the ones that don't.
1013  * 2: If O_MAGIC is not set, the string "\~" is replaced with the text
1014  *    from the last substitute command's replacement string.  If O_MAGIC
1015  *    is set, it's the string "~".
1016  * 3: The pattern \<ptrn\> does "word" searches, convert it to use the
1017  *    new RE escapes.
1018  *
1019  * !!!/XXX
1020  * This doesn't exactly match the historic behavior of vi because we do
1021  * the ~ substitution before calling the RE engine, so magic characters
1022  * in the replacement string will be expanded by the RE engine, and they
1023  * weren't historically.  It's a bug.
1024  */
1025 static int
1026 re_conv(sp, ptrnp, plenp, replacedp)
1027         SCR *sp;
1028         char **ptrnp;
1029         size_t *plenp;
1030         int *replacedp;
1031 {
1032         size_t blen, len, needlen;
1033         int magic;
1034         char *bp, *p, *t;
1035
1036         /*
1037          * First pass through, we figure out how much space we'll need.
1038          * We do it in two passes, on the grounds that most of the time
1039          * the user is doing a search and won't have magic characters.
1040          * That way we can skip most of the memory allocation and copies.
1041          */
1042         magic = 0;
1043         for (p = *ptrnp, len = *plenp, needlen = 0; len > 0; ++p, --len)
1044                 switch (*p) {
1045                 case '\\':
1046                         if (len > 1) {
1047                                 --len;
1048                                 switch (*++p) {
1049                                 case '<':
1050                                         magic = 1;
1051                                         needlen += sizeof(RE_WSTART);
1052                                         break;
1053                                 case '>':
1054                                         magic = 1;
1055                                         needlen += sizeof(RE_WSTOP);
1056                                         break;
1057                                 case '~':
1058                                         if (!O_ISSET(sp, O_MAGIC)) {
1059                                                 magic = 1;
1060                                                 needlen += sp->repl_len;
1061                                         }
1062                                         break;
1063                                 case '.':
1064                                 case '[':
1065                                 case '*':
1066                                         if (!O_ISSET(sp, O_MAGIC)) {
1067                                                 magic = 1;
1068                                                 needlen += 1;
1069                                         }
1070                                         break;
1071                                 default:
1072                                         needlen += 2;
1073                                 }
1074                         } else
1075                                 needlen += 1;
1076                         break;
1077                 case '~':
1078                         if (O_ISSET(sp, O_MAGIC)) {
1079                                 magic = 1;
1080                                 needlen += sp->repl_len;
1081                         }
1082                         break;
1083                 case '.':
1084                 case '[':
1085                 case '*':
1086                         if (!O_ISSET(sp, O_MAGIC)) {
1087                                 magic = 1;
1088                                 needlen += 2;
1089                         }
1090                         break;
1091                 default:
1092                         needlen += 1;
1093                         break;
1094                 }
1095
1096         if (!magic) {
1097                 *replacedp = 0;
1098                 return (0);
1099         }
1100
1101         /* Get enough memory to hold the final pattern. */
1102         *replacedp = 1;
1103         GET_SPACE_RET(sp, bp, blen, needlen);
1104
1105         for (p = *ptrnp, len = *plenp, t = bp; len > 0; ++p, --len)
1106                 switch (*p) {
1107                 case '\\':
1108                         if (len > 1) {
1109                                 --len;
1110                                 switch (*++p) {
1111                                 case '<':
1112                                         memcpy(t,
1113                                             RE_WSTART, sizeof(RE_WSTART) - 1);
1114                                         t += sizeof(RE_WSTART) - 1;
1115                                         break;
1116                                 case '>':
1117                                         memcpy(t,
1118                                             RE_WSTOP, sizeof(RE_WSTOP) - 1);
1119                                         t += sizeof(RE_WSTOP) - 1;
1120                                         break;
1121                                 case '~':
1122                                         if (O_ISSET(sp, O_MAGIC))
1123                                                 *t++ = '~';
1124                                         else {
1125                                                 memcpy(t,
1126                                                     sp->repl, sp->repl_len);
1127                                                 t += sp->repl_len;
1128                                         }
1129                                         break;
1130                                 case '.':
1131                                 case '[':
1132                                 case '*':
1133                                         if (O_ISSET(sp, O_MAGIC))
1134                                                 *t++ = '\\';
1135                                         *t++ = *p;
1136                                         break;
1137                                 default:
1138                                         *t++ = '\\';
1139                                         *t++ = *p;
1140                                 }
1141                         } else
1142                                 *t++ = '\\';
1143                         break;
1144                 case '~':
1145                         if (O_ISSET(sp, O_MAGIC)) {
1146                                 memcpy(t, sp->repl, sp->repl_len);
1147                                 t += sp->repl_len;
1148                         } else
1149                                 *t++ = '~';
1150                         break;
1151                 case '.':
1152                 case '[':
1153                 case '*':
1154                         if (!O_ISSET(sp, O_MAGIC))
1155                                 *t++ = '\\';
1156                         *t++ = *p;
1157                         break;
1158                 default:
1159                         *t++ = *p;
1160                         break;
1161                 }
1162
1163         *ptrnp = bp;
1164         *plenp = t - bp;
1165         return (0);
1166 }
1167
1168 /*
1169  * re_tag_conv --
1170  *      Convert a tags search path into something that the POSIX
1171  *      1003.2 RE functions can handle.
1172  */
1173 static int
1174 re_tag_conv(sp, ptrnp, plenp, replacedp)
1175         SCR *sp;
1176         char **ptrnp;
1177         size_t *plenp;
1178         int *replacedp;
1179 {
1180         size_t blen, len;
1181         int lastdollar;
1182         char *bp, *p, *t;
1183
1184         len = *plenp;
1185
1186         /* Max memory usage is 2 times the length of the string. */
1187         *replacedp = 1;
1188         GET_SPACE_RET(sp, bp, blen, len * 2);
1189
1190         p = *ptrnp;
1191         t = bp;
1192
1193         /* If the last character is a '/' or '?', we just strip it. */
1194         if (len > 0 && (p[len - 1] == '/' || p[len - 1] == '?'))
1195                 --len;
1196
1197         /* If the next-to-last or last character is a '$', it's magic. */
1198         if (len > 0 && p[len - 1] == '$') {
1199                 --len;
1200                 lastdollar = 1;
1201         } else
1202                 lastdollar = 0;
1203
1204         /* If the first character is a '/' or '?', we just strip it. */
1205         if (len > 0 && (p[0] == '/' || p[0] == '?')) {
1206                 ++p;
1207                 --len;
1208         }
1209
1210         /* If the first or second character is a '^', it's magic. */
1211         if (p[0] == '^') {
1212                 *t++ = *p++;
1213                 --len;
1214         }
1215
1216         /*
1217          * Escape every other magic character we can find, meanwhile stripping
1218          * the backslashes ctags inserts when escaping the search delimiter
1219          * characters.
1220          */
1221         for (; len > 0; --len) {
1222                 if (p[0] == '\\' && (p[1] == '/' || p[1] == '?')) {
1223                         ++p;
1224                         --len;
1225                 } else if (strchr("^.[]$*", p[0]))
1226                         *t++ = '\\';
1227                 *t++ = *p++;
1228         }
1229         if (lastdollar)
1230                 *t++ = '$';
1231
1232         *ptrnp = bp;
1233         *plenp = t - bp;
1234         return (0);
1235 }
1236
1237 /*
1238  * re_cscope_conv --
1239  *       Convert a cscope search path into something that the POSIX
1240  *      1003.2 RE functions can handle.
1241  */
1242 static int
1243 re_cscope_conv(sp, ptrnp, plenp, replacedp)
1244         SCR *sp;
1245         char **ptrnp;
1246         size_t *plenp;
1247         int *replacedp;
1248 {
1249         size_t blen, len, nspaces;
1250         char *bp, *p, *t;
1251
1252         /*
1253          * Each space in the source line printed by cscope represents an
1254          * arbitrary sequence of spaces, tabs, and comments.
1255          */
1256 #define CSCOPE_RE_SPACE         "([ \t]|/\\*([^*]|\\*/)*\\*/)*"
1257         for (nspaces = 0, p = *ptrnp, len = *plenp; len > 0; ++p, --len)
1258                 if (*p == ' ')
1259                         ++nspaces;
1260
1261         /*
1262          * Allocate plenty of space:
1263          *      the string, plus potential escaping characters;
1264          *      nspaces + 2 copies of CSCOPE_RE_SPACE;
1265          *      ^, $, nul terminator characters.
1266          */
1267         *replacedp = 1;
1268         len = (p - *ptrnp) * 2 + (nspaces + 2) * sizeof(CSCOPE_RE_SPACE) + 3;
1269         GET_SPACE_RET(sp, bp, blen, len);
1270
1271         p = *ptrnp;
1272         t = bp;
1273
1274         *t++ = '^';
1275         memcpy(t, CSCOPE_RE_SPACE, sizeof(CSCOPE_RE_SPACE) - 1);
1276         t += sizeof(CSCOPE_RE_SPACE) - 1;
1277
1278         for (len = *plenp; len > 0; ++p, --len)
1279                 if (*p == ' ') {
1280                         memcpy(t, CSCOPE_RE_SPACE, sizeof(CSCOPE_RE_SPACE) - 1);
1281                         t += sizeof(CSCOPE_RE_SPACE) - 1;
1282                 } else {
1283                         if (strchr("\\^.[]$*+?()|{}", *p))
1284                                 *t++ = '\\';
1285                         *t++ = *p;
1286                 }
1287
1288         memcpy(t, CSCOPE_RE_SPACE, sizeof(CSCOPE_RE_SPACE) - 1);
1289         t += sizeof(CSCOPE_RE_SPACE) - 1;
1290         *t++ = '$';
1291
1292         *ptrnp = bp;
1293         *plenp = t - bp;
1294         return (0);
1295 }
1296
1297 /*
1298  * re_error --
1299  *      Report a regular expression error.
1300  *
1301  * PUBLIC: void re_error __P((SCR *, int, regex_t *));
1302  */
1303 void
1304 re_error(sp, errcode, preg)
1305         SCR *sp;
1306         int errcode;
1307         regex_t *preg;
1308 {
1309         size_t s;
1310         char *oe;
1311
1312         s = regerror(errcode, preg, "", 0);
1313         if ((oe = malloc(s)) == NULL)
1314                 msgq(sp, M_SYSERR, NULL);
1315         else {
1316                 (void)regerror(errcode, preg, oe, s);
1317                 msgq(sp, M_ERR, "RE error: %s", oe);
1318                 free(oe);
1319         }
1320 }
1321
1322 /*
1323  * re_sub --
1324  *      Do the substitution for a regular expression.
1325  */
1326 static int
1327 re_sub(sp, ip, lbp, lbclenp, lblenp, match)
1328         SCR *sp;
1329         char *ip;                       /* Input line. */
1330         char **lbp;
1331         size_t *lbclenp, *lblenp;
1332         regmatch_t match[10];
1333 {
1334         enum { C_NOTSET, C_LOWER, C_ONELOWER, C_ONEUPPER, C_UPPER } conv;
1335         size_t lbclen, lblen;           /* Local copies. */
1336         size_t mlen;                    /* Match length. */
1337         size_t rpl;                     /* Remaining replacement length. */
1338         char *rp;                       /* Replacement pointer. */
1339         int ch;
1340         int no;                         /* Match replacement offset. */
1341         char *p, *t;                    /* Buffer pointers. */
1342         char *lb;                       /* Local copies. */
1343
1344         lb = *lbp;                      /* Get local copies. */
1345         lbclen = *lbclenp;
1346         lblen = *lblenp;
1347
1348         /*
1349          * QUOTING NOTE:
1350          *
1351          * There are some special sequences that vi provides in the
1352          * replacement patterns.
1353          *       & string the RE matched (\& if nomagic set)
1354          *      \# n-th regular subexpression
1355          *      \E end \U, \L conversion
1356          *      \e end \U, \L conversion
1357          *      \l convert the next character to lower-case
1358          *      \L convert to lower-case, until \E, \e, or end of replacement
1359          *      \u convert the next character to upper-case
1360          *      \U convert to upper-case, until \E, \e, or end of replacement
1361          *
1362          * Otherwise, since this is the lowest level of replacement, discard
1363          * all escaping characters.  This (hopefully) matches historic practice.
1364          */
1365 #define OUTCH(ch, nltrans) {                                            \
1366         CHAR_T __ch = (ch);                                             \
1367         u_int __value = KEY_VAL(sp, __ch);                              \
1368         if (nltrans && (__value == K_CR || __value == K_NL)) {          \
1369                 NEEDNEWLINE(sp);                                        \
1370                 sp->newl[sp->newl_cnt++] = lbclen;                      \
1371         } else if (conv != C_NOTSET) {                                  \
1372                 switch (conv) {                                         \
1373                 case C_ONELOWER:                                        \
1374                         conv = C_NOTSET;                                \
1375                         /* FALLTHROUGH */                               \
1376                 case C_LOWER:                                           \
1377                         if (isupper(__ch))                              \
1378                                 __ch = tolower(__ch);                   \
1379                         break;                                          \
1380                 case C_ONEUPPER:                                        \
1381                         conv = C_NOTSET;                                \
1382                         /* FALLTHROUGH */                               \
1383                 case C_UPPER:                                           \
1384                         if (islower(__ch))                              \
1385                                 __ch = toupper(__ch);                   \
1386                         break;                                          \
1387                 default:                                                \
1388                         abort();                                        \
1389                 }                                                       \
1390         }                                                               \
1391         NEEDSP(sp, 1, p);                                               \
1392         *p++ = __ch;                                                    \
1393         ++lbclen;                                                       \
1394 }
1395         conv = C_NOTSET;
1396         for (rp = sp->repl, rpl = sp->repl_len, p = lb + lbclen; rpl--;) {
1397                 switch (ch = *rp++) {
1398                 case '&':
1399                         if (O_ISSET(sp, O_MAGIC)) {
1400                                 no = 0;
1401                                 goto subzero;
1402                         }
1403                         break;
1404                 case '\\':
1405                         if (rpl == 0)
1406                                 break;
1407                         --rpl;
1408                         switch (ch = *rp) {
1409                         case '&':
1410                                 ++rp;
1411                                 if (!O_ISSET(sp, O_MAGIC)) {
1412                                         no = 0;
1413                                         goto subzero;
1414                                 }
1415                                 break;
1416                         case '0': case '1': case '2': case '3': case '4':
1417                         case '5': case '6': case '7': case '8': case '9':
1418                                 no = *rp++ - '0';
1419 subzero:                        if (match[no].rm_so == -1 ||
1420                                     match[no].rm_eo == -1)
1421                                         break;
1422                                 mlen = match[no].rm_eo - match[no].rm_so;
1423                                 for (t = ip + match[no].rm_so; mlen--; ++t)
1424                                         OUTCH(*t, 0);
1425                                 continue;
1426                         case 'e':
1427                         case 'E':
1428                                 ++rp;
1429                                 conv = C_NOTSET;
1430                                 continue;
1431                         case 'l':
1432                                 ++rp;
1433                                 conv = C_ONELOWER;
1434                                 continue;
1435                         case 'L':
1436                                 ++rp;
1437                                 conv = C_LOWER;
1438                                 continue;
1439                         case 'u':
1440                                 ++rp;
1441                                 conv = C_ONEUPPER;
1442                                 continue;
1443                         case 'U':
1444                                 ++rp;
1445                                 conv = C_UPPER;
1446                                 continue;
1447                         default:
1448                                 ++rp;
1449                                 break;
1450                         }
1451                 }
1452                 OUTCH(ch, 1);
1453         }
1454
1455         *lbp = lb;                      /* Update caller's information. */
1456         *lbclenp = lbclen;
1457         *lblenp = lblen;
1458         return (0);
1459 }