![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to re.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to re.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 ! root 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: } ! 958:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.