2.11BSD#431 - /usr/src/new/jove/re.c

   1: /***************************************************************************
   2:  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
   3:  * is provided to you without charge, and with no warranty.  You may give  *
   4:  * away copies of JOVE, including sources, provided that this notice is    *
   5:  * included in all the files.                                              *
   6:  ***************************************************************************/
   7: 
   8: /* search package */
   9: 
  10: #include "jove.h"
  11: #include "ctype.h"
  12: #ifdef MAC
  13: #	undef private
  14: #	define private
  15: #endif
  16: 
  17: #ifdef  LINT_ARGS
  18: private char * insert(char *, char *, int);
  19: 
  20: private void
  21:     REreset(void),
  22:     search(int, int, int);
  23: private int
  24:     backref(int, char *),
  25:     do_comp(int),
  26:     member(char *, int, int),
  27:     REgetc(void),
  28:     REmatch(char *, char *);
  29: #else
  30: private char * insert();
  31: 
  32: private void
  33:     REreset(),
  34:     search();
  35: private int
  36:     backref(),
  37:     do_comp(),
  38:     member(),
  39:     REgetc(),
  40:     REmatch();
  41: #endif	/* LINT_ARGS */
  42: 
  43: #ifdef MAC
  44: #	undef private
  45: #	define private static
  46: #endif
  47: 
  48: #define NALTS   16  /* number of alternate search strings */
  49: 
  50: char    searchstr[128],
  51:     compbuf[256],       /* global default compbuf */
  52:     rep_search[128],    /* replace search string */
  53:     rep_str[128],       /* contains replacement string */
  54:     *cur_compb,     /* usually points at compbuf */
  55:     REbuf[LBSIZE],      /* points at line we're scanning */
  56:     *alternates[NALTS];
  57: 
  58: int REdirection;
  59: 
  60: int CaseIgnore = 0,
  61:     WrapScan = 0,
  62:     UseRE = 0;
  63: 
  64: #define cind_cmp(a, b)  (CaseEquiv[a] == CaseEquiv[b])
  65: 
  66: private int REpeekc;
  67: private char    *REptr;
  68: 
  69: private int
  70: REgetc()
  71: {
  72:     int c;
  73: 
  74:     if ((c = REpeekc) != -1)
  75:         REpeekc = -1;
  76:     else if (*REptr)
  77:         c = *REptr++;
  78:     else
  79:         c = 0;
  80: 
  81:     return c;
  82: }
  83: 
  84: #define STAR    01  /* Match any number of last RE. */
  85: #define AT_BOL  2   /* ^ */
  86: #define AT_EOL  4   /* $ */
  87: #define AT_BOW  6   /* \< */
  88: #define AT_EOW  8   /* \> */
  89: #define OPENP   10  /* \( */
  90: #define CLOSEP  12  /* \) */
  91: #define CURLYB  14  /* \{ */
  92: 
  93: #define NOSTR   14  /* Codes <= NOSTR can't be *'d. */
  94: 
  95: #define ANYC    NOSTR+2     /* . */
  96: #define NORMC   ANYC+2      /* normal character */
  97: #define CINDC   NORMC+2     /* case independent character */
  98: #define ONE_OF  CINDC+2     /* [xxx] */
  99: #define NONE_OF ONE_OF+2    /* [^xxx] */
 100: #define BACKREF NONE_OF+2   /* \# */
 101: #define EOP BACKREF+2   /* end of pattern */
 102: 
 103: #define NPAR    10  /* [0-9] - 0th is the entire matched string, i.e. & */
 104: private int nparens;
 105: private char    *comp_p,
 106:         *start_p,
 107:         **alt_p,
 108:         **alt_endp;
 109: 
 110: void
 111: REcompile(pattern, re, into_buf, alt_bufp)
 112: char    *pattern,
 113:     *into_buf,
 114:     **alt_bufp;
 115: {
 116:     REptr = pattern;
 117:     REpeekc = -1;
 118:     comp_p = cur_compb = start_p = into_buf;
 119:     alt_p = alt_bufp;
 120:     alt_endp = alt_p + NALTS;
 121:     *alt_p++ = comp_p;
 122:     nparens = 0;
 123:     (void) do_comp(re ? OKAY_RE : NORM);
 124:     *alt_p = 0;
 125: }
 126: 
 127: /* compile the pattern into an internal code */
 128: 
 129: private int
 130: do_comp(kind)
 131: {
 132:     char    *last_p,
 133:         *chr_cnt = 0;
 134:     int parens[NPAR],
 135:         *parenp,
 136:         c,
 137:         ret_code;
 138: 
 139:     parenp = parens;
 140:     last_p = 0;
 141:     ret_code = 1;
 142: 
 143:     if (kind == OKAY_RE) {
 144:         *comp_p++ = OPENP;
 145:         *comp_p++ = nparens;
 146:         *parenp++ = nparens++;
 147:         start_p = comp_p;
 148:     }
 149: 
 150:     while (c = REgetc()) {
 151:         if (comp_p > &cur_compb[(sizeof compbuf) - 6])
 152: toolong:        complain("Search string too long/complex.");
 153:         if (c != '*')
 154:             last_p = comp_p;
 155: 
 156:         if (kind == NORM && index(".[*", c) != 0)
 157:             goto defchar;
 158:         switch (c) {
 159:         case '\\':
 160:             switch (c = REgetc()) {
 161:             case 0:
 162:                 complain("Premature end of pattern.");
 163: 
 164:             case '{':
 165:                 {
 166:                     char    *wcntp;     /* word count */
 167: 
 168:                     *comp_p++ = CURLYB;
 169:                     wcntp = comp_p;
 170:                     *comp_p++ = 0;
 171:                     for (;;) {
 172:                         int comp_val;
 173:                         char    *comp_len;
 174: 
 175:                         comp_len = comp_p++;
 176:                         comp_val = do_comp(IN_CB);
 177:                         *comp_len = comp_p - comp_len;
 178:                         (*wcntp) += 1;
 179:                         if (comp_val == 0)
 180:                             break;
 181:                     }
 182:                     break;
 183:                 }
 184: 
 185:             case '}':
 186:                 if (kind != IN_CB)
 187:                     complain("Unexpected \\}.");
 188:                 ret_code = 0;
 189:                 goto outahere;
 190: 
 191:             case '(':
 192:                 if (nparens >= NPAR)
 193:                     complain("Too many ('s; max is %d.", NPAR);
 194:                 *comp_p++ = OPENP;
 195:                 *comp_p++ = nparens;
 196:                 *parenp++ = nparens++;
 197:                 break;
 198: 
 199:             case ')':
 200:                 if (parenp == parens)
 201:                     complain("Too many )'s.");
 202:                 *comp_p++ = CLOSEP;
 203:                 *comp_p++ = *--parenp;
 204:                 break;
 205: 
 206:             case '|':
 207:                 if (alt_p >= alt_endp)
 208:                     complain("Too many alternates; max %d.", NALTS);
 209:                 *comp_p++ = CLOSEP;
 210:                 *comp_p++ = *--parenp;
 211:                 *comp_p++ = EOP;
 212:                 *alt_p++ = comp_p;
 213:                 nparens = 0;
 214:                 *comp_p++ = OPENP;
 215:                 *comp_p++ = nparens;
 216:                 *parenp++ = nparens++;
 217:                 start_p = comp_p;
 218:                 break;
 219: 
 220:             case '1':
 221:             case '2':
 222:             case '3':
 223:             case '4':
 224:             case '5':
 225:             case '6':
 226:             case '7':
 227:             case '8':
 228:             case '9':
 229:                 *comp_p++ = BACKREF;
 230:                 *comp_p++ = c - '0';
 231:                 break;
 232: 
 233:             case '<':
 234:                 *comp_p++ = AT_BOW;
 235:                 break;
 236: 
 237:             case '>':
 238:                 *comp_p++ = AT_EOW;
 239:                 break;
 240: 
 241:             default:
 242:                 goto defchar;
 243:             }
 244:             break;
 245: 
 246:         case ',':
 247:             if (kind != IN_CB)
 248:                 goto defchar;
 249:             goto outahere;
 250: 
 251:         case '.':
 252:             *comp_p++ = ANYC;
 253:             break;
 254: 
 255:         case '^':
 256:             if (comp_p == start_p) {
 257:                 *comp_p++ = AT_BOL;
 258:                 break;
 259:             }
 260:             goto defchar;
 261: 
 262:         case '$':
 263:             if ((REpeekc = REgetc()) != 0 && REpeekc != '\\')
 264:                 goto defchar;
 265:             *comp_p++ = AT_EOL;
 266:             break;
 267: 
 268:         case '[':
 269:             {
 270:                 int chrcnt;
 271: 
 272:                 *comp_p++ = ONE_OF;
 273:             if (comp_p + 16 >= &cur_compb[(sizeof compbuf)])
 274:                 goto toolong;
 275:                 bzero(comp_p, 16);
 276:                 if ((REpeekc = REgetc()) == '^') {
 277:                     *last_p = NONE_OF;
 278:                     /* Get it for real this time. */
 279:                     (void) REgetc();
 280:                 }
 281:                 chrcnt = 1;
 282:                 while ((c = REgetc()) != ']' && c != 0) {
 283:                     if (c == '\\')
 284:                         c = REgetc();
 285:                 else if ((REpeekc = REgetc()) == '-') {
 286:                     int c2;
 287: 
 288:                     (void) REgetc();     /* reread '-' */
 289:                     c2 = REgetc();
 290:                     while (c < c2) {
 291:                         comp_p[c/8] |= (1 << (c%8));
 292:                         c += 1;
 293:                     }
 294:                 }
 295:                 comp_p[c/8] |= (1 << (c%8));
 296:                     chrcnt += 1;
 297:                 }
 298:                 if (c == 0)
 299:                     complain("Missing ].");
 300:                 if (chrcnt == 1)
 301:                     complain("Empty [].");
 302:                 comp_p += 16;
 303:                 break;
 304:             }
 305: 
 306:         case '*':
 307:             if (last_p == 0 || *last_p <= NOSTR)
 308:                 goto defchar;
 309: 
 310:             /* The * operator applies only to the previous
 311: 			   character.  If we were building a chr_cnt at
 312: 			   the time we got the *, we have to remove the
 313: 			   last character from the chr_cnt (by decrementing
 314: 			   *chr_cnt) and replacing it with a new STAR entry.
 315: 
 316: 			   If we are decrementing the count to 0, we just
 317: 			   delete the chr_cnt entry altogether, replacing
 318: 			   it with the STAR entry. */
 319: 
 320:             if (chr_cnt) {
 321:                 char    lastc = chr_cnt[*chr_cnt];
 322: 
 323:             /* The * operator applies only to the previous
 324:  			   character.  If we were building a chr_cnt at
 325:  			   the time we got the *, we have to remove the
 326:  			   last character from the chr_cnt (by decrementing
 327:  			   *chr_cnt) and replacing it with a new STAR entry.
 328: 
 329:  			   If we are decrementing the count to 0, we just
 330:  			   delete the chr_cnt entry altogether, replacing
 331:  			   it with the STAR entry. */
 332: 
 333:                 if (*chr_cnt == 1) {
 334:                     comp_p = chr_cnt;
 335:                     comp_p[-1] |= STAR;
 336:                     *comp_p++ = lastc;
 337:                 } else {
 338:                     comp_p = chr_cnt + *chr_cnt;
 339:                     (*chr_cnt) -= 1;
 340:                     *comp_p++ = chr_cnt[-1] | STAR;
 341:                     *comp_p++ = lastc;
 342:                 }
 343:             } else
 344:                 *last_p |= STAR;
 345:             break;
 346:         default:
 347: defchar:        if (chr_cnt)
 348:                 (*chr_cnt) += 1;
 349:             else {
 350:                 *comp_p++ = (CaseIgnore) ? CINDC : NORMC;
 351:                 chr_cnt = comp_p++;
 352:                 *chr_cnt = 1;   /* last_p[1] = 1; */
 353:             }
 354:             *comp_p++ = c;
 355:             continue;
 356:         }
 357:         chr_cnt = FALSE;
 358:     }
 359: outahere:
 360:     /* End of pattern, let's do some error checking. */
 361:     if (kind == OKAY_RE) {
 362:         *comp_p++ = CLOSEP;
 363:         *comp_p++ = *--parenp;
 364:     }
 365:     if (parenp != parens)
 366:         complain("Unmatched ()'s.");
 367:     if (kind == IN_CB && c == 0)    /* End of pattern with \}. */
 368:         complain("Missing \\}.");
 369:     *comp_p++ = EOP;
 370: 
 371:     return ret_code;
 372: }
 373: 
 374: private char    *pstrtlst[NPAR],    /* index into REbuf */
 375:         *pendlst[NPAR],
 376:         *REbolp,
 377:         *locs,
 378:         *loc1,
 379:         *loc2;
 380: 
 381: int REbom,
 382:     REeom,      /* beginning and end of match */
 383:     REalt_num;  /* if alternatives, which one matched? */
 384: 
 385: private int
 386: backref(n, linep)
 387: register char   *linep;
 388: {
 389:     register char   *backsp,
 390:             *backep;
 391: 
 392:     backsp = pstrtlst[n];
 393:     backep = pendlst[n];
 394:     while (*backsp++ == *linep++)
 395:         if (backsp >= backep)
 396:             return 1;
 397:     return 0;
 398: }
 399: 
 400: private int
 401: member(comp_p, c, af)
 402: register char   *comp_p;
 403: register int    c,
 404:         af;
 405: {
 406:     if (c == 0)
 407:         return 0;   /* try to match EOL always fails */
 408:     if (comp_p[c/8] & (1 << (c%8)))
 409:         return af;
 410:     return !af;
 411: }
 412: 
 413: private int
 414: REmatch(linep, comp_p)
 415: register char   *linep,
 416:         *comp_p;
 417: {
 418:     char    *first_p = linep;
 419:     register int    n;
 420: 
 421:     for (;;) switch (*comp_p++) {
 422:     case NORMC:
 423:         n = *comp_p++;
 424:         while (--n >= 0)
 425:             if (*linep++ != *comp_p++)
 426:                 return 0;
 427:         continue;
 428: 
 429:     case CINDC: /* case independent comparison */
 430:         n = *comp_p++;
 431:         while (--n >= 0)
 432:             if (!cind_cmp(*linep++, *comp_p++))
 433:                 return 0;
 434:         continue;
 435: 
 436:     case EOP:
 437:         loc2 = linep;
 438:         REeom = (loc2 - REbolp);
 439:         return 1;   /* Success! */
 440: 
 441:     case AT_BOL:
 442:         if (linep == REbolp)
 443:             continue;
 444:         return 0;
 445: 
 446:     case AT_EOL:
 447:         if (*linep == 0)
 448:             continue;
 449:         return 0;
 450: 
 451:     case ANYC:
 452:         if (*linep++ != 0)
 453:             continue;
 454:         return 0;
 455: 
 456:     case AT_BOW:
 457:         if (ismword(*linep) && (linep == REbolp || !ismword(linep[-1])))
 458:             continue;
 459:         return 0;
 460: 
 461:     case AT_EOW:
 462:         if ((*linep == 0 || !ismword(*linep)) &&
 463:             (linep != REbolp && ismword(linep[-1])))
 464:             continue;
 465:         return 0;
 466: 
 467:     case ONE_OF:
 468:     case NONE_OF:
 469:         if (member(comp_p, *linep++, comp_p[-1] == ONE_OF)) {
 470:             comp_p += 16;
 471:             continue;
 472:         }
 473:         return 0;
 474: 
 475:     case OPENP:
 476:         pstrtlst[*comp_p++] = linep;
 477:         continue;
 478: 
 479:     case CLOSEP:
 480:         pendlst[*comp_p++] = linep;
 481:         continue;
 482: 
 483:     case BACKREF:
 484:         if (pstrtlst[n = *comp_p++] == 0) {
 485:             s_mess("\\%d was not specified.", n + 1);
 486:             return 0;
 487:         }
 488:         if (backref(n, linep)) {
 489:             linep += pendlst[n] - pstrtlst[n];
 490:             continue;
 491:         }
 492:         return 0;
 493: 
 494:     case CURLYB:
 495:         {
 496:             int wcnt,
 497:                 any;
 498: 
 499:             wcnt = *comp_p++;
 500:             any = 0;
 501: 
 502:             while (--wcnt >= 0) {
 503:                 if (any == 0)
 504:                     any = REmatch(linep, comp_p + 1);
 505:                 comp_p += *comp_p;
 506:             }
 507:             if (any == 0)
 508:                 return 0;
 509:             linep = loc2;
 510:             continue;
 511:         }
 512: 
 513:     case ANYC | STAR:
 514:         first_p = linep;
 515:         while (*linep++)
 516:             ;
 517:         goto star;
 518: 
 519:     case NORMC | STAR:
 520:         first_p = linep;
 521:         while (*comp_p == *linep++)
 522:             ;
 523:         comp_p += 1;
 524:         goto star;
 525: 
 526:     case CINDC | STAR:
 527:         first_p = linep;
 528:         while (cind_cmp(*comp_p, *linep++))
 529:             ;
 530:         comp_p += 1;
 531:         goto star;
 532: 
 533:     case ONE_OF | STAR:
 534:     case NONE_OF | STAR:
 535:         first_p = linep;
 536:         while (member(comp_p, *linep++, comp_p[-1] == (ONE_OF | STAR)))
 537:             ;
 538:         comp_p += 16;
 539:         goto star;
 540: 
 541:     case BACKREF | STAR:
 542:         first_p = linep;
 543:         n = *comp_p++;
 544:         while (backref(n, linep))
 545:             linep += pendlst[n] - pstrtlst[n];
 546:         while (linep >= first_p) {
 547:             if (REmatch(linep, comp_p))
 548:                 return 1;
 549:             linep -= pendlst[n] - pstrtlst[n];
 550:         }
 551:         continue;
 552: 
 553: star:       do {
 554:             linep -= 1;
 555:             if (linep < locs)
 556:                 break;
 557:             if (REmatch(linep, comp_p))
 558:                 return 1;
 559:         } while (linep > first_p);
 560:         return 0;
 561: 
 562:     default:
 563:         complain("RE error match (%d).", comp_p[-1]);
 564:     }
 565:     /* NOTREACHED. */
 566: }
 567: 
 568: private void
 569: REreset()
 570: {
 571:     register int    i;
 572: 
 573:     for (i = 0; i < NPAR; i++)
 574:         pstrtlst[i] = pendlst[i] = 0;
 575: }
 576: 
 577: /* Index LINE at OFFSET, the compiled EXPR, with alternates ALTS.  If
 578:    lbuf_okay is nonzero it's okay to use linebuf if LINE is the current
 579:    line.  This should save lots of time in things like paren matching in
 580:    LISP mode.  Saves all that copying from linebuf to REbuf.  substitute()
 581:    is the guy who calls re_lindex with lbuf_okay as 0, since the substitution
 582:    gets placed in linebuf ... doesn't work too well when the source and
 583:    destination strings are the same.  I hate all these arguments!
 584: 
 585:    This code is cumbersome, repetetive for reasons of efficiency.  Fast
 586:    search is a must as far as I am concerned. */
 587: 
 588: int
 589: re_lindex(line, offset, expr, alts, lbuf_okay)
 590: Line    *line;
 591: char    *expr,
 592:     **alts;
 593: {
 594:     int isquick;
 595:     register int    firstc,
 596:             c;
 597:     register char   *resp;
 598: 
 599:     REreset();
 600:     if (lbuf_okay) {
 601:         REbolp = lbptr(line);
 602:         if (offset == -1)
 603:             offset = strlen(REbolp);    /* arg! */
 604:     } else {
 605:         REbolp = ltobuf(line, REbuf);
 606:         if (offset == -1) { /* Reverse search, find end of line. */
 607:             extern int  Jr_Len;
 608: 
 609:             offset = Jr_Len;    /* Just Read Len. */
 610:         }
 611:     }
 612:     resp = REbolp;
 613:     isquick = ((expr[0] == NORMC || expr[0] == CINDC) &&
 614:            (alternates[1] == 0));
 615:     if (isquick) {
 616:         firstc = expr[2];
 617:         if (expr[0] == CINDC)
 618:             firstc = CaseEquiv[firstc];
 619:     }
 620:     locs = REbolp + offset;
 621: 
 622:     if (REdirection == FORWARD) {
 623:         do {
 624:         char    **altp = alts;
 625: 
 626:         if (isquick) {
 627:             if (expr[0] == NORMC)
 628:                 while ((c = *locs++) != 0 && c != firstc)
 629:                     ;
 630:             else
 631:                 while (((c = *locs++) != 0) &&
 632:                     (CaseEquiv[c] != firstc))
 633:                     ;
 634:             if (*--locs == 0)
 635:                 break;
 636:         }
 637:         REalt_num = 1;
 638:         while (*altp) {
 639:             if (REmatch(locs, *altp++)) {
 640:                 loc1 = locs;
 641:                 REbom = loc1 - REbolp;
 642:                 return 1;
 643:             }
 644:             REalt_num += 1;
 645:         }
 646:         } while (*locs++);
 647:     } else {
 648:         do {
 649:         char    **altp = alts;
 650: 
 651:         if (isquick) {
 652:             if (expr[0] == NORMC) {
 653:                 while (locs >= REbolp && *locs-- != firstc)
 654:                     ;
 655:                 if (*++locs != firstc)
 656:                     break;
 657:             } else {
 658:                 while (locs >= REbolp && CaseEquiv[*locs--] != firstc)
 659:                     ;
 660:                 if (CaseEquiv[*++locs] != firstc)
 661:                     break;
 662:             }
 663:         }
 664:         REalt_num = 1;
 665:         while (*altp) {
 666:             if (REmatch(locs, *altp++)) {
 667:                 loc1 = locs;
 668:                 REbom = loc1 - REbolp;
 669:                 return 1;
 670:             }
 671:             REalt_num += 1;
 672:         }
 673:         } while (--locs >= resp);
 674:     }
 675: 
 676:     return 0;
 677: }
 678: 
 679: int okay_wrap = 0;  /* Do a wrap search ... not when we're
 680: 			   parsing errors ... */
 681: 
 682: Bufpos *
 683: dosearch(pattern, dir, re)
 684: char    *pattern;
 685: {
 686:     Bufpos  *pos;
 687: 
 688:     if (bobp() && eobp())   /* Can't match!  There's no buffer. */
 689:         return 0;
 690: 
 691:     REcompile(pattern, re, compbuf, alternates);
 692: 
 693:     pos = docompiled(dir, compbuf, alternates);
 694:     return pos;
 695: }
 696: 
 697: Bufpos *
 698: docompiled(dir, expr, alts)
 699: char    *expr,
 700:     **alts;
 701: {
 702:     static Bufpos   ret;
 703:     register Line   *lp;
 704:     register int    offset;
 705:     int we_wrapped = NO;
 706: 
 707:     lsave();
 708:     /* Search now lsave()'s so it doesn't make any assumptions on
 709: 	   whether the the contents of curline/curchar are in linebuf.
 710: 	   Nowhere does search write all over linebuf.  However, we have to
 711: 	   be careful about what calls we make here, because many of them
 712: 	   assume (and rightly so) that curline is in linebuf. */
 713: 
 714:     REdirection = dir;
 715:     lp = curline;
 716:     offset = curchar;
 717:     if (dir == BACKWARD) {
 718:         if (bobp()) {
 719:             if (okay_wrap && WrapScan)
 720:                 goto doit;
 721:             return 0;
 722:         }
 723:         /* here we simulate BackChar() */
 724:         if (bolp()) {
 725:             lp = lp->l_prev;
 726:             offset = strlen(lbptr(lp));
 727:         } else
 728:             offset -= 1;
 729:     } else if ((dir == FORWARD) &&
 730:            (lbptr(lp)[offset] == '\0') &&
 731:            !lastp(lp)) {
 732:         lp = lp->l_next;
 733:         offset = 0;
 734:     }
 735: 
 736:     do {
 737:         if (re_lindex(lp, offset, expr, alts, YES))
 738:             break;
 739: doit:       lp = (dir == FORWARD) ? lp->l_next : lp->l_prev;
 740:         if (lp == 0) {
 741:             if (okay_wrap && WrapScan) {
 742:                 lp = (dir == FORWARD) ?
 743:                      curbuf->b_first : curbuf->b_last;
 744:                 we_wrapped = YES;
 745:             } else
 746:                  break;
 747:         }
 748:         if (dir == FORWARD)
 749:             offset = 0;
 750:         else
 751:             offset = -1;    /* signals re_lindex ... */
 752:     } while (lp != curline);
 753: 
 754:     if (lp == curline && we_wrapped)
 755:         lp = 0;
 756:     if (lp == 0)
 757:         return 0;
 758:     ret.p_line = lp;
 759:     ret.p_char = (dir == FORWARD) ? REeom : REbom;
 760:     return &ret;
 761: }
 762: 
 763: private char *
 764: insert(off, endp, which)
 765: char    *off,
 766:     *endp;
 767: {
 768:     register char   *pp;
 769:     register int    n;
 770: 
 771:     n = pendlst[which] - pstrtlst[which];
 772:     pp = pstrtlst[which];
 773:     while (--n >= 0) {
 774:         *off++ = *pp++;
 775:         if (off >= endp)
 776:             len_error(ERROR);
 777:     }
 778:     return off;
 779: }
 780: 
 781: /* Perform the substitution.  If DELP is nonzero the matched string is
 782:    deleted, i.e., the substitution string is not inserted. */
 783: 
 784: void
 785: re_dosub(tobuf, delp)
 786: char    *tobuf;
 787: {
 788:     register char   *tp,
 789:             *rp,
 790:             *repp;
 791:     int c;
 792:     char    *endp;
 793: 
 794:     tp = tobuf;
 795:     endp = tp + LBSIZE;
 796:     rp = REbuf;
 797:     repp = rep_str;
 798: 
 799:     while (rp < loc1)
 800:         *tp++ = *rp++;
 801: 
 802:     if (!delp) while (c = *repp++) {
 803:         if (c == '\\') {
 804:             c = *repp++;
 805:             if (c == '\0') {
 806:                 *tp++ = '\\';
 807:                 goto endchk;
 808:             } else if (c >= '1' && c <= nparens + '1') {
 809:                 tp = insert(tp, endp, c - '0');
 810:                 continue;
 811:             }
 812:         } else if (c == '&') {
 813:             tp = insert(tp, endp, 0);
 814:             continue;
 815:         }
 816:         *tp++ = c;
 817: endchk:     if (tp >= endp)
 818:             len_error(ERROR);
 819:     }
 820:     rp = loc2;
 821:     loc2 = REbuf + max(1, tp - tobuf);
 822:     REeom = loc2 - REbuf;
 823:     /* At least one character past the match, to prevent an infinite
 824: 	   number of replacements in the same position, e.g.,
 825: 	   replace "^" with "". */
 826:     while (*tp++ = *rp++)
 827:         if (tp >= endp)
 828:             len_error(ERROR);
 829: }
 830: 
 831: void
 832: putmatch(which, buf, size)
 833: char    *buf;
 834: {
 835:     *(insert(buf, buf + size, which)) = 0;
 836: }
 837: 
 838: void
 839: setsearch(str)
 840: char    *str;
 841: {
 842:     strcpy(searchstr, str);
 843: }
 844: 
 845: char *
 846: getsearch()
 847: {
 848:     return searchstr;
 849: }
 850: 
 851: void
 852: RErecur()
 853: {
 854:     char    sbuf[sizeof searchstr],
 855:         cbuf[sizeof compbuf],
 856:         repbuf[sizeof rep_str],
 857:         *altbuf[NALTS];
 858:     int npars;
 859:     Mark    *m = MakeMark(curline, REbom, M_FLOATER);
 860: 
 861:     message("Type C-X C-C to continue with query replace.");
 862: 
 863:     npars = nparens;
 864:     byte_copy(compbuf, cbuf, sizeof compbuf);
 865:     byte_copy(searchstr, sbuf, sizeof searchstr);
 866:     byte_copy(rep_str, repbuf, sizeof rep_str);
 867:     byte_copy((char *) alternates, (char *) altbuf, sizeof alternates);
 868:     Recur();
 869:     nparens = npars;
 870:     byte_copy(cbuf, compbuf, sizeof compbuf);
 871:     byte_copy(sbuf, searchstr, sizeof searchstr);
 872:     byte_copy(repbuf, rep_str, sizeof rep_str);
 873:     byte_copy((char *) altbuf, (char *) alternates, sizeof alternates);
 874:     if (!is_an_arg())
 875:         ToMark(m);
 876:     DelMark(m);
 877: }
 878: 
 879: void
 880: ForSearch()
 881: {
 882:     search(FORWARD, UseRE, YES);
 883: }
 884: 
 885: void
 886: RevSearch()
 887: {
 888:     search(BACKWARD, UseRE, YES);
 889: }
 890: 
 891: void
 892: FSrchND()
 893: {
 894:     search(FORWARD, UseRE, NO);
 895: }
 896: 
 897: void
 898: RSrchND()
 899: {
 900:     search(BACKWARD, UseRE, NO);
 901: }
 902: 
 903: private void
 904: search(dir, re, setdefault)
 905: {
 906:     Bufpos  *newdot;
 907:     char    *s;
 908: 
 909:     s = ask(searchstr, ProcFmt);
 910:     if (setdefault)
 911:         setsearch(s);
 912:     okay_wrap = YES;
 913:     newdot = dosearch(s, dir, re);
 914:     okay_wrap = NO;
 915:     if (newdot == 0) {
 916:         if (WrapScan)
 917:             complain("No \"%s\" in buffer.", s);
 918:         else
 919:             complain("No \"%s\" found to %s.", s,
 920:                  (dir == FORWARD) ? "bottom" : "top");
 921:     }
 922:     PushPntp(newdot->p_line);
 923:     SetDot(newdot);
 924: }
 925: 
 926: /* Do we match PATTERN at OFFSET in BUF? */
 927: 
 928: int
 929: LookingAt(pattern, buf, offset)
 930: char    *pattern,
 931:     *buf;
 932: {
 933:     register char   **alt = alternates;
 934: 
 935:     REcompile(pattern, 1, compbuf, alternates);
 936:     REreset();
 937:     locs = buf + offset;
 938:     REbolp = buf;
 939: 
 940:     while (*alt)
 941:         if (REmatch(locs, *alt++))
 942:             return 1;
 943:     return 0;
 944: }
 945: 
 946: int
 947: look_at(expr)
 948: char    *expr;
 949: {
 950:     REcompile(expr, 0, compbuf, alternates);
 951:     REreset();
 952:     locs = linebuf + curchar;
 953:     REbolp = linebuf;
 954:     if (REmatch(locs, alternates[0]))
 955:         return 1;
 956:     return 0;
 957: }

Defined functions

Defined variables

Defined macros