Return to re.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / jove

Annotation of 43BSD/contrib/jove/re.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.