Return to re1.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove

Annotation of 43BSDTahoe/new/jove/re1.c, revision 1.1

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: #include "jove.h"
        !             9: #include "io.h"
        !            10: #include "re.h"
        !            11: #include "ctype.h"
        !            12: 
        !            13: #ifdef MAC
        !            14: #      include "mac.h"
        !            15: #else
        !            16: #      include <sys/stat.h>
        !            17: #endif
        !            18: 
        !            19: #ifdef MAC
        !            20: #      undef private
        !            21: #      define private
        !            22: #endif
        !            23: 
        !            24: #ifdef LINT_ARGS
        !            25: private Bufpos * doisearch(int, int, int);
        !            26: 
        !            27: private void
        !            28:        IncSearch(int),
        !            29:        replace(int, int);
        !            30: private int
        !            31:        isearch(int, Bufpos *),
        !            32:        lookup(char *, char *, char *, char *),
        !            33:        substitute(int, Line *, int, Line *, int);
        !            34: #else
        !            35: private Bufpos * doisearch();
        !            36: 
        !            37: private void
        !            38:        IncSearch(),
        !            39:        replace();
        !            40: private int
        !            41:        isearch(),
        !            42:        lookup(),
        !            43:        substitute();
        !            44: #endif /* LINT_ARGS */
        !            45: 
        !            46: #ifdef MAC
        !            47: #      undef private
        !            48: #      define private static
        !            49: #endif
        !            50: 
        !            51: private int
        !            52: substitute(query, l1, char1, l2, char2)
        !            53: Line   *l1,
        !            54:        *l2;
        !            55: {
        !            56:        Line    *lp;
        !            57:        int     numdone = 0,
        !            58:                offset = curchar,
        !            59:                stop = NO;
        !            60:        disk_line       UNDO_da = 0;
        !            61:        Line            *UNDO_lp = 0;
        !            62: 
        !            63:        lsave();
        !            64:        REdirection = FORWARD;
        !            65: 
        !            66:        lp = l1;
        !            67:        for (lp = l1; (lp != l2->l_next) && !stop; lp = lp->l_next) {
        !            68:                offset = (lp == l1) ? char1 : 0;
        !            69:                while (!stop && re_lindex(lp, offset, compbuf, alternates, 0)) {
        !            70:                        if (lp == l2 && REeom > char2)  /* nope, leave this alone */
        !            71:                                break;
        !            72:                        DotTo(lp, REeom);
        !            73:                        offset = curchar;
        !            74:                        if (query) {
        !            75:                                message("Replace (Type '?' for help)? ");
        !            76: reswitch:                      redisplay();
        !            77:                                switch (CharUpcase(getchar())) {
        !            78:                                case '.':
        !            79:                                        stop = YES;
        !            80:                                        /* Fall into ... */
        !            81: 
        !            82:                                case ' ':
        !            83:                                case 'Y':
        !            84:                                        break;
        !            85: 
        !            86:                                case BS:
        !            87:                                case RUBOUT:
        !            88:                                case 'N':
        !            89:                                        if (linebuf[offset++] == '\0')
        !            90:                                                goto nxtline;
        !            91:                                        continue;
        !            92: 
        !            93:                                case CTL('W'):
        !            94:                                        re_dosub(linebuf, YES);
        !            95:                                        numdone += 1;
        !            96:                                        offset = curchar = REbom;
        !            97:                                        makedirty(curline);
        !            98:                                        /* Fall into ... */
        !            99: 
        !           100:                                case CTL('R'):
        !           101:                                case 'R':
        !           102:                                        RErecur();
        !           103:                                        offset = curchar;
        !           104:                                        lp = curline;
        !           105:                                        continue;
        !           106: 
        !           107:                                case CTL('U'):
        !           108:                                case 'U':
        !           109:                                        if (UNDO_lp == 0)
        !           110:                                                continue;
        !           111:                                        lp = UNDO_lp;
        !           112:                                        lp->l_dline = UNDO_da | DIRTY;
        !           113:                                        offset = 0;
        !           114:                                        numdone -= 1;
        !           115:                                        continue;
        !           116: 
        !           117:                                case 'P':
        !           118:                                case '!':
        !           119:                                        query = 0;
        !           120:                                        break;
        !           121: 
        !           122:                                case CR:
        !           123:                                case LF:
        !           124:                                case 'Q':
        !           125:                                        goto done;
        !           126: 
        !           127:                                case CTL('L'):
        !           128:                                        RedrawDisplay();
        !           129:                                        goto reswitch;
        !           130: 
        !           131:                                default:
        !           132:                                        rbell();
        !           133: message("Space or Y, Period, Rubout or N, C-R or R, C-W, C-U or U, P or !, Return.");
        !           134:                                        goto reswitch;
        !           135:                                }
        !           136:                        }
        !           137:                        re_dosub(linebuf, NO);
        !           138:                        numdone += 1;
        !           139:                        modify();
        !           140:                        offset = curchar = REeom;
        !           141:                        makedirty(curline);
        !           142:                        if (query) {
        !           143:                                message(mesgbuf);       /* no blinking */
        !           144:                                redisplay();            /* show the change */
        !           145:                        }
        !           146:                        UNDO_da = curline->l_dline;
        !           147:                        UNDO_lp = curline;
        !           148:                        if (linebuf[offset] == 0)
        !           149: nxtline:                       break;
        !           150:                }
        !           151:        }
        !           152: done:  return numdone;
        !           153: }
        !           154: 
        !           155: /* prompt for search and replacement strings and do the substitution */
        !           156: private void
        !           157: replace(query, inreg)
        !           158: {
        !           159:        Mark    *m;
        !           160:        char    *rep_ptr;
        !           161:        Line    *l1 = curline,
        !           162:                *l2 = curbuf->b_last;
        !           163:        int     char1 = curchar,
        !           164:                char2 = length(curbuf->b_last),
        !           165:                numdone;
        !           166: 
        !           167:        if (inreg) {
        !           168:                m = CurMark();
        !           169:                l2 = m->m_line;
        !           170:                char2 = m->m_char;
        !           171:                (void) fixorder(&l1, &char1, &l2, &char2);
        !           172:        }
        !           173: 
        !           174:        /* get search string */
        !           175:        strcpy(rep_search, ask(rep_search[0] ? rep_search : (char *) 0, ProcFmt));
        !           176:        REcompile(rep_search, UseRE, compbuf, alternates);
        !           177:        /* Now the replacement string.  Do_ask() so the user can play with
        !           178:           the default (previous) replacement string by typing C-R in ask(),
        !           179:           OR, he can just hit Return to replace with nothing. */
        !           180:        rep_ptr = do_ask("\r\n", (int (*)()) 0, rep_str, ": %f %s with ", rep_search);
        !           181:        if (rep_ptr == 0)
        !           182:                rep_ptr = NullStr;
        !           183:        strcpy(rep_str, rep_ptr);
        !           184: 
        !           185:        if (((numdone = substitute(query, l1, char1, l2, char2)) != 0) &&
        !           186:            (inreg == NO)) {
        !           187:                do_set_mark(l1, char1);
        !           188:                add_mess(" ");          /* just making things pretty */
        !           189:        } else
        !           190:                message("");
        !           191:        add_mess("(%d substitution%n)", numdone, numdone);
        !           192: }
        !           193: 
        !           194: void
        !           195: RegReplace()
        !           196: {
        !           197:        replace(0, YES);
        !           198: }
        !           199: 
        !           200: void
        !           201: QRepSearch()
        !           202: {
        !           203:        replace(1, NO);
        !           204: }
        !           205: 
        !           206: void
        !           207: RepSearch()
        !           208: {
        !           209:        replace(0, NO);
        !           210: }
        !           211: 
        !           212: /* Lookup a tag in tag file FILE.  FILE is assumed to be sorted
        !           213:    alphabetically.  The FASTTAGS code, which is implemented with
        !           214:    a binary search, depends on this assumption.  If it's not true
        !           215:    it is possible to comment out the fast tag code (which is clearly
        !           216:    labeled) and everything else will just work. */
        !           217: 
        !           218: private int
        !           219: lookup(searchbuf, filebuf, tag, file)
        !           220: char   *searchbuf,
        !           221:        *filebuf,
        !           222:        *tag,
        !           223:        *file;
        !           224: {
        !           225:        register int    taglen = strlen(tag);
        !           226:        char    line[BUFSIZ],
        !           227:                pattern[128];
        !           228:        register File   *fp;
        !           229:        struct stat     stbuf;
        !           230:        int     fast = YES,
        !           231:                success = NO;
        !           232:        register off_t  lower, upper;
        !           233: 
        !           234:        sprintf(pattern, "^%s[^\t]*\t*\\([^\t]*\\)\t*[?/]\\([^?/]*\\)[?/]", tag);
        !           235:        fp = open_file(file, iobuff, F_READ, !COMPLAIN, QUIET);
        !           236:        if (fp == NIL)
        !           237:                return 0;
        !           238: 
        !           239:        /* ********BEGIN FAST TAG CODE******** */
        !           240: 
        !           241:        if (stat(file, &stbuf) < 0)
        !           242:                fast = NO;
        !           243:        else {
        !           244:                lower = 0;
        !           245:                upper = stbuf.st_size;
        !           246:                if (upper - lower < BUFSIZ)
        !           247:                        fast = NO;
        !           248:        }
        !           249:        if (fast == YES) for (;;) {
        !           250:                off_t   mid;
        !           251:                int     whichway,
        !           252:                        chars_eq;
        !           253: 
        !           254:                if (upper - lower < BUFSIZ) {
        !           255:                        f_seek(fp, lower);
        !           256:                        break;                  /* stop this nonsense */
        !           257:                }
        !           258:                mid = (lower + upper) / 2;
        !           259:                f_seek(fp, mid);
        !           260:                f_toNL(fp);
        !           261:                if (f_gets(fp, line, sizeof line) == EOF)
        !           262:                        break;
        !           263:                chars_eq = numcomp(line, tag);
        !           264:                if (chars_eq == taglen && iswhite(line[chars_eq]))
        !           265:                        goto found;
        !           266:                whichway = line[chars_eq] - tag[chars_eq];
        !           267:                if (whichway < 0) {             /* line is BEFORE tag */
        !           268:                        lower = mid;
        !           269:                        continue;
        !           270:                } else if (whichway > 0) {      /* line is AFTER tag */
        !           271:                        upper = mid;
        !           272:                        continue;
        !           273:                }
        !           274:        }
        !           275:        f_toNL(fp);
        !           276:        /* END FAST TAG CODE */
        !           277: 
        !           278:        while (f_gets(fp, line, sizeof line) != EOF) {
        !           279:                int     cmp;
        !           280: 
        !           281:                if (line[0] > *tag)
        !           282:                        break;
        !           283:                else if ((cmp = strncmp(line, tag, taglen)) > 0)
        !           284:                        break;
        !           285:                else if (cmp < 0)
        !           286:                        continue;
        !           287:                /* if we get here, we've found the match */
        !           288: found:         if (!LookingAt(pattern, line, 0)) {
        !           289:                        complain("I thought I saw it!");
        !           290:                        break;
        !           291:                } else {
        !           292:                        putmatch(1, filebuf, FILESIZE);
        !           293:                        putmatch(2, searchbuf, 100);
        !           294:                        success = YES;
        !           295:                        break;
        !           296:                }
        !           297:        }
        !           298:        close_file(fp);
        !           299:                
        !           300:        if (success == NO)
        !           301:                s_mess("Can't find tag \"%s\".", tag);
        !           302:        return success;
        !           303: }
        !           304: 
        !           305: #ifndef MSDOS
        !           306: char   TagFile[FILESIZE] = "./tags";
        !           307: #else /* MSDOS */
        !           308: char   TagFile[FILESIZE] = "tags";
        !           309: #endif /* MSDOS */
        !           310: 
        !           311: void
        !           312: find_tag(tag, localp)
        !           313: char   *tag;
        !           314: {
        !           315:        char    filebuf[FILESIZE],
        !           316:                sstr[100],
        !           317:                tfbuf[FILESIZE];
        !           318:        register Bufpos *bp;
        !           319:        register Buffer *b;
        !           320:        char    *tagfname;
        !           321: 
        !           322:        if (!localp) {
        !           323:                char    prompt[128];
        !           324: 
        !           325:                sprintf(prompt, "With tag file (%s default): ", TagFile);
        !           326:                tagfname = ask_file(prompt, TagFile, tfbuf);
        !           327:        } else
        !           328:                tagfname = TagFile;
        !           329:        if (lookup(sstr, filebuf, tag, tagfname) == 0)
        !           330:                return;
        !           331:        set_mark();
        !           332:        b = do_find(curwind, filebuf, 0);
        !           333:        if (curbuf != b)
        !           334:                SetABuf(curbuf);
        !           335:        SetBuf(b);
        !           336:        if ((bp = dosearch(sstr, BACKWARD, 0)) == 0 &&
        !           337:            ((bp = dosearch(sstr, FORWARD, 0)) == 0))
        !           338:                message("Well, I found the file, but the tag is missing.");
        !           339:        else
        !           340:                SetDot(bp);
        !           341: }
        !           342: 
        !           343: void
        !           344: FindTag()
        !           345: {
        !           346:        int     localp = !is_an_arg();
        !           347:        char    tag[128];
        !           348: 
        !           349:        strcpy(tag, ask((char *) 0, ProcFmt));
        !           350:        find_tag(tag, localp);
        !           351: }
        !           352: 
        !           353: /* Find Tag at Dot. */
        !           354: 
        !           355: void
        !           356: FDotTag()
        !           357: {
        !           358:        int     c1 = curchar,
        !           359:                c2 = c1;
        !           360:        char    tagname[50];
        !           361: 
        !           362:        if (!ismword(linebuf[curchar]))
        !           363:                complain("Not a tag!");
        !           364:        while (c1 > 0 && ismword(linebuf[c1 - 1]))
        !           365:                c1 -= 1;
        !           366:        while (ismword(linebuf[c2]))
        !           367:                c2 += 1;
        !           368: 
        !           369:        null_ncpy(tagname, linebuf + c1, c2 - c1);
        !           370:        find_tag(tagname, !is_an_arg());
        !           371: }
        !           372: 
        !           373: /* I-search returns a code saying what to do:
        !           374:    STOP:       We found the match, so unwind the stack and leave
        !           375:                where it is.
        !           376:    DELETE:     Rubout the last command.
        !           377:    BACKUP:     Back up to where the isearch was last NOT failing.
        !           378: 
        !           379:    When a character is typed it is appended to the search string, and
        !           380:    then, isearch is called recursively.  When C-S or C-R is typed, isearch
        !           381:    is again called recursively. */
        !           382: 
        !           383: #define STOP   1
        !           384: #define DELETE 2
        !           385: #define BACKUP 3
        !           386: #define TOSTART        4
        !           387: 
        !           388: static char    ISbuf[128],
        !           389:                *incp = 0;
        !           390: int    SExitChar = CR;
        !           391: 
        !           392: #define cmp_char(a, b) ((a) == (b) || (CaseIgnore && (CharUpcase(a) == CharUpcase(b))))
        !           393: 
        !           394: static Bufpos *
        !           395: doisearch(dir, c, failing)
        !           396: register int   c,
        !           397:                dir,
        !           398:                failing;
        !           399: {
        !           400:        static Bufpos   buf;
        !           401:        Bufpos  *bp;
        !           402:        extern int      okay_wrap;
        !           403: 
        !           404:        if (c == CTL('S') || c == CTL('R'))
        !           405:                goto dosrch;
        !           406: 
        !           407:        if (failing)
        !           408:                return 0;
        !           409:        DOTsave(&buf);
        !           410:        if (dir == FORWARD) {
        !           411:                if (cmp_char(linebuf[curchar], c)) {
        !           412:                        buf.p_char = curchar + 1;
        !           413:                        return &buf;
        !           414:                }
        !           415:        } else {
        !           416:                if (look_at(ISbuf))
        !           417:                        return &buf;
        !           418:        }
        !           419: dosrch:        okay_wrap = YES;
        !           420:        if ((bp = dosearch(ISbuf, dir, 0)) == 0)
        !           421:                rbell();        /* ring the first time there's no match */
        !           422:        okay_wrap = NO;
        !           423:        return bp;
        !           424: }
        !           425: 
        !           426: void
        !           427: IncFSearch()
        !           428: {
        !           429:        IncSearch(FORWARD);
        !           430: }
        !           431: 
        !           432: void
        !           433: IncRSearch()
        !           434: {
        !           435:        IncSearch(BACKWARD);
        !           436: }
        !           437: 
        !           438: private void
        !           439: IncSearch(dir)
        !           440: {
        !           441:        Bufpos  save_env;
        !           442: 
        !           443:        DOTsave(&save_env);
        !           444:        ISbuf[0] = 0;
        !           445:        incp = ISbuf;
        !           446:        if (isearch(dir, &save_env) == TOSTART)
        !           447:                SetDot(&save_env);
        !           448:        else {
        !           449:                if (LineDist(curline, save_env.p_line) >= MarkThresh)
        !           450:                        do_set_mark(save_env.p_line, save_env.p_char);
        !           451:        }
        !           452:        setsearch(ISbuf);
        !           453: }
        !           454: 
        !           455: /* Nicely recursive. */
        !           456: 
        !           457: private int
        !           458: isearch(dir, bp)
        !           459: Bufpos *bp;
        !           460: {
        !           461:        Bufpos  pushbp;
        !           462:        int     c,
        !           463:                ndir,
        !           464:                failing;
        !           465:        char    *orig_incp;
        !           466: 
        !           467:        if (bp != 0) {          /* Move to the new position. */
        !           468:                pushbp.p_line = bp->p_line;
        !           469:                pushbp.p_char = bp->p_char;
        !           470:                SetDot(bp);
        !           471:                failing = 0;
        !           472:        } else {
        !           473:                DOTsave(&pushbp);
        !           474:                failing = 1;
        !           475:        }
        !           476:        orig_incp = incp;
        !           477:        ndir = dir;             /* Same direction as when we got here, unless
        !           478:                                   we change it with C-S or C-R. */
        !           479:        for (;;) {
        !           480:                SetDot(&pushbp);
        !           481:                message(NullStr);
        !           482:                if (failing)
        !           483:                        add_mess("Failing ");
        !           484:                if (dir == BACKWARD)
        !           485:                        add_mess("reverse-");
        !           486:                add_mess("I-search: %s", ISbuf);
        !           487:                DrawMesg(NO);
        !           488:                add_mess(NullStr);      /* tell me this is disgusting ... */
        !           489:                c = getch();
        !           490:                if (c == SExitChar)
        !           491:                        return STOP;
        !           492:                if (c == AbortChar) {
        !           493:                        /* If we're failing, we backup until we're no longer
        !           494:                           failing or we've reached the beginning; else, we
        !           495:                           just about the search and go back to the start. */
        !           496:                        if (failing)
        !           497:                                return BACKUP;
        !           498:                        return TOSTART;
        !           499:                }
        !           500:                switch (c) {
        !           501:                case RUBOUT:
        !           502:                case BS:
        !           503:                        return DELETE;
        !           504: 
        !           505:                case CTL('\\'):
        !           506:                        c = CTL('S');
        !           507: 
        !           508:                case CTL('S'):
        !           509:                case CTL('R'):
        !           510:                        /* If this is the first time through and we have a
        !           511:                           search string left over from last time, use that
        !           512:                           one now. */
        !           513:                        if (incp == ISbuf) {
        !           514:                                strcpy(ISbuf, getsearch());
        !           515:                                incp = &ISbuf[strlen(ISbuf)];
        !           516:                        }
        !           517:                        ndir = (c == CTL('S')) ? FORWARD : BACKWARD;
        !           518:                        /* If we're failing and we're not changing our
        !           519:                           direction, don't recur since there's no way
        !           520:                           the search can work. */
        !           521:                        if (failing && ndir == dir) {
        !           522:                                rbell();
        !           523:                                continue;
        !           524:                        }
        !           525:                        break;
        !           526: 
        !           527:                case '\\':
        !           528:                        if (incp > &ISbuf[(sizeof ISbuf) - 1]) {
        !           529:                                rbell();
        !           530:                                continue;
        !           531:                        }
        !           532:                        *incp++ = '\\';
        !           533:                        add_mess("\\");
        !           534:                        /* Fall into ... */
        !           535: 
        !           536:                case CTL('Q'):
        !           537:                case CTL('^'):
        !           538:                        add_mess("");
        !           539:                        c = getch() | 0400;
        !           540:                        /* Fall into ... */
        !           541: 
        !           542:                default:
        !           543:                        if (c & 0400)
        !           544:                                c &= CHARMASK;
        !           545:                        else {
        !           546: #ifdef IBMPC
        !           547:                                if (c == RUBOUT || c == 0xff || (c < ' ' && c != '\t')) {
        !           548: #else
        !           549:                                if (c > RUBOUT || (c < ' ' && c != '\t')) {
        !           550: #endif
        !           551:                                        Ungetc(c);
        !           552:                                        return STOP;
        !           553:                                }
        !           554:                        }
        !           555:                        if (incp > &ISbuf[(sizeof ISbuf) - 1]) {
        !           556:                                rbell();
        !           557:                                continue;
        !           558:                        }
        !           559:                        *incp++ = c;
        !           560:                        *incp = 0;
        !           561:                        break;
        !           562:                }
        !           563:                add_mess("%s", orig_incp);
        !           564:                add_mess(" ...");       /* so we know what's going on */
        !           565:                DrawMesg(NO);           /* do it now */
        !           566:                switch (isearch(ndir, doisearch(ndir, c, failing))) {
        !           567:                case TOSTART:
        !           568:                        return TOSTART;
        !           569: 
        !           570:                case STOP:
        !           571:                        return STOP;
        !           572: 
        !           573:                case BACKUP:
        !           574:                        /* If we're not failing, we just continue to to the
        !           575:                           for loop; otherwise we keep returning to the 
        !           576:                           previous levels until we find one that isn't
        !           577:                           failing OR we reach the beginning. */
        !           578:                        if (failing)
        !           579:                                return BACKUP;
        !           580:                        /* Fall into ... */
        !           581: 
        !           582:                case DELETE:
        !           583:                        incp = orig_incp;
        !           584:                        *incp = 0;
        !           585:                        continue;
        !           586:                }
        !           587:        }
        !           588: }

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