Return to ed.c CVS log

Up to [Research Unix] / researchv10no / cmd / ed

Annotation of researchv10no/cmd/ed/ed.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Editor
        !             3:  */
        !             4: #include <ansi.h>
        !             5: #include <posix.h>
        !             6: 
        !             7: #define        NULL    0
        !             8: #define        FNSIZE  128
        !             9: #define        LBSIZE  4096
        !            10: #define        BLKSIZE 4096
        !            11: #define        NBLK    2047
        !            12: #define        ESIZE   256
        !            13: #define        GBSIZE  256
        !            14: #define        NBRA    10
        !            15: #ifndef EOF
        !            16: #define        EOF     -1
        !            17: #endif /* EOF */
        !            18: #define        KSIZE   9
        !            19: 
        !            20: #define        CBRA    1
        !            21: #define        CCHR    2
        !            22: #define        CDOT    4
        !            23: #define        CCL     6
        !            24: #define        NCCL    8
        !            25: #define        CDOL    10
        !            26: #define        CEFIL   11
        !            27: #define        CKET    12
        !            28: #define        CBACK   14
        !            29: #define        CCIRC   15
        !            30: 
        !            31: #define        STAR    01
        !            32: 
        !            33: char   Q[]     = "";
        !            34: char   T[]     = "TMP";
        !            35: char   hex[]   = "0123456789abcdef";
        !            36: #define        READ    0
        !            37: #define        WRITE   1
        !            38: 
        !            39: int    peekc;
        !            40: int    lastc;
        !            41: char   savedfile[FNSIZE];
        !            42: char   file[FNSIZE];
        !            43: short  linebuf[LBSIZE];
        !            44: short  rhsbuf[LBSIZE/2];
        !            45: short  expbuf[ESIZE+4];
        !            46: short  genbuf[LBSIZE];
        !            47: int    *zero;
        !            48: int    *dot;
        !            49: int    *dol;
        !            50: int    given;
        !            51: int    *addr1;
        !            52: int    *addr2;
        !            53: char   iobuf[LBSIZE];
        !            54: long   count;
        !            55: char   *nextip;
        !            56: short  *linebp;
        !            57: int    ninbuf;
        !            58: int    io;
        !            59: int    pflag;
        !            60: void   (*oldhup)(int);
        !            61: void   (*oldquit)(int);
        !            62: int    vflag   = 1;
        !            63: int    oflag;
        !            64: int    listf;
        !            65: int    listn;
        !            66: int    col;
        !            67: char   *globp;
        !            68: int    tfile   = -1;
        !            69: int    tline;
        !            70: char   *tfname;
        !            71: short  *loc1;
        !            72: short  *loc2;
        !            73: unsigned char ibuff[BLKSIZE];
        !            74: int    iblock  = -1;
        !            75: unsigned char obuff[BLKSIZE];
        !            76: int    oblock  = -1;
        !            77: int    ichanged;
        !            78: int    nleft;
        !            79: char   WRERR[] = "WRITE ERROR";
        !            80: int    names[26];
        !            81: int    anymarks;
        !            82: short  *braslist[NBRA];
        !            83: short  *braelist[NBRA];
        !            84: int    nbra;
        !            85: int    subnewa;
        !            86: int    subolda;
        !            87: int    fchange;
        !            88: int    wrapp;
        !            89: int    bpagesize = 20;
        !            90: unsigned nlall = 128;
        !            91: jmp_buf        savej;
        !            92: 
        !            93: int*   address(void);
        !            94: int    getchr(void);
        !            95: short* getline(int);
        !            96: unsigned char *getblock(int, int);
        !            97: short* place(short*, short*, short*);
        !            98: void   commands(void);
        !            99: void   quit(void);
        !           100: void   printcom(void);
        !           101: void   error(char*);
        !           102: void   nonzero(void);
        !           103: void   newline(void);
        !           104: void   rdelete(int*, int*);
        !           105: void   setnoaddr(void);
        !           106: void   init(void);
        !           107: void   putst(char*);
        !           108: void   putshst(short*);
        !           109: void   squeeze(int);
        !           110: void   setwide(void);
        !           111: void   putfile(void);
        !           112: void   putd(void);
        !           113: void   callunix(void);
        !           114: void   dosub(void);
        !           115: void   reverse(int*, int*);
        !           116: void   compile(int);
        !           117: void   putchr(int);
        !           118: int    append(int(*)(void), int*);
        !           119: void   add(int);
        !           120: void   browse(void);
        !           121: void   filename(int);
        !           122: void   global(int);
        !           123: void   join(void);
        !           124: void   move(int);
        !           125: void   exfile(void);
        !           126: void   substitute(int);
        !           127: int    getfile(void);
        !           128: int    gettty(void);
        !           129: int    compsub(void);
        !           130: int    getsub(void);
        !           131: int    getcopy(void);
        !           132: int    getnum(void);
        !           133: int    execute(int*);
        !           134: int    putline(void);
        !           135: int    advance(short*, short*);
        !           136: int    cclass(short*, int, int);
        !           137: int    backref(int, short*);
        !           138: 
        !           139: void   onintr(int);
        !           140: void   onquit(int);
        !           141: void   onhup(int);
        !           142: 
        !           143: main(int argc, char *argv[])
        !           144: {
        !           145:        char *p1, *p2;
        !           146:        void (*oldintr)(int);
        !           147: 
        !           148:        oldquit = signal(SIGQUIT, SIG_IGN);
        !           149:        oldhup = signal(SIGHUP, SIG_IGN);
        !           150:        oldintr = signal(SIGINT, SIG_IGN);
        !           151:        if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
        !           152:                signal(SIGTERM, onquit);
        !           153:        argv++;
        !           154:        while (argc > 1 && **argv=='-') {
        !           155:                switch((*argv)[1]) {
        !           156: 
        !           157:                case '\0':
        !           158:                        vflag = 0;
        !           159:                        break;
        !           160: 
        !           161:                case 'q':
        !           162:                        signal(SIGQUIT, SIG_DFL);
        !           163:                        vflag = 1;
        !           164:                        break;
        !           165: 
        !           166:                case 'o':
        !           167:                        oflag = 1;
        !           168:                        break;
        !           169:                }
        !           170:                argv++;
        !           171:                argc--;
        !           172:        }
        !           173:        if (oflag) {
        !           174:                p1 = "/dev/stdout";
        !           175:                p2 = savedfile;
        !           176:                while (*p2++ = *p1++)
        !           177:                        ;
        !           178:                globp = "a";
        !           179:        } else if (*argv) {
        !           180:                p1 = *argv;
        !           181:                p2 = savedfile;
        !           182:                while (*p2++ = *p1++)
        !           183:                        if (p2 >= &savedfile[sizeof(savedfile)])
        !           184:                                p2--;
        !           185:                globp = "r";
        !           186:        }
        !           187:        zero = (int*)malloc(nlall*sizeof(int));
        !           188:        tfname = tmpnam(0);
        !           189:        init();
        !           190:        if (((int)oldintr & 01) == 0)
        !           191:                signal(SIGINT, onintr);
        !           192:        if (((int)oldhup & 01) == 0)
        !           193:                signal(SIGHUP, onhup);
        !           194:        setjmp(savej);
        !           195:        commands();
        !           196:        quit();
        !           197: }
        !           198: 
        !           199: void
        !           200: commands(void)
        !           201: {
        !           202:        int *a1, c, temp;
        !           203:        char lastsep;
        !           204: 
        !           205:        for (;;) {
        !           206:        if (pflag) {
        !           207:                pflag = 0;
        !           208:                addr1 = addr2 = dot;
        !           209:                printcom();
        !           210:        }
        !           211:        c = '\n';
        !           212:        for (addr1 = 0;;) {
        !           213:                lastsep = c;
        !           214:                a1 = address();
        !           215:                c = getchr();
        !           216:                if (c!=',' && c!=';')
        !           217:                        break;
        !           218:                if (lastsep==',')
        !           219:                        error(Q);
        !           220:                if (a1==0) {
        !           221:                        a1 = zero+1;
        !           222:                        if (a1>dol)
        !           223:                                a1--;
        !           224:                }
        !           225:                addr1 = a1;
        !           226:                if (c==';')
        !           227:                        dot = a1;
        !           228:        }
        !           229:        if (lastsep!='\n' && a1==0)
        !           230:                a1 = dol;
        !           231:        if ((addr2=a1)==0) {
        !           232:                given = 0;
        !           233:                addr2 = dot;    
        !           234:        }
        !           235:        else
        !           236:                given = 1;
        !           237:        if (addr1==0)
        !           238:                addr1 = addr2;
        !           239:        switch(c) {
        !           240: 
        !           241:        case 'a':
        !           242:                add(0);
        !           243:                continue;
        !           244: 
        !           245:        case 'b':
        !           246:                nonzero();
        !           247:                browse();
        !           248:                continue;
        !           249: 
        !           250:        case 'c':
        !           251:                nonzero();
        !           252:                newline();
        !           253:                rdelete(addr1, addr2);
        !           254:                append(gettty, addr1-1);
        !           255:                continue;
        !           256: 
        !           257:        case 'd':
        !           258:                nonzero();
        !           259:                newline();
        !           260:                rdelete(addr1, addr2);
        !           261:                continue;
        !           262: 
        !           263:        case 'E':
        !           264:                fchange = 0;
        !           265:                c = 'e';
        !           266:        case 'e':
        !           267:                setnoaddr();
        !           268:                if (vflag && fchange) {
        !           269:                        fchange = 0;
        !           270:                        error(Q);
        !           271:                }
        !           272:                filename(c);
        !           273:                init();
        !           274:                addr2 = zero;
        !           275:                goto caseread;
        !           276: 
        !           277:        case 'f':
        !           278:                setnoaddr();
        !           279:                filename(c);
        !           280:                putst(savedfile);
        !           281:                continue;
        !           282: 
        !           283:        case 'g':
        !           284:                global(1);
        !           285:                continue;
        !           286: 
        !           287:        case 'i':
        !           288:                add(-1);
        !           289:                continue;
        !           290: 
        !           291: 
        !           292:        case 'j':
        !           293:                if (!given)
        !           294:                        addr2++;
        !           295:                newline();
        !           296:                join();
        !           297:                continue;
        !           298: 
        !           299:        case 'k':
        !           300:                nonzero();
        !           301:                if ((c = getchr()) < 'a' || c > 'z')
        !           302:                        error(Q);
        !           303:                newline();
        !           304:                names[c-'a'] = *addr2 & ~01;
        !           305:                anymarks |= 01;
        !           306:                continue;
        !           307: 
        !           308:        case 'm':
        !           309:                move(0);
        !           310:                continue;
        !           311: 
        !           312:        case 'n':
        !           313:                listn++;
        !           314:                newline();
        !           315:                printcom();
        !           316:                continue;
        !           317: 
        !           318:        case '\n':
        !           319:                if (a1==0) {
        !           320:                        a1 = dot+1;
        !           321:                        addr2 = a1;
        !           322:                        addr1 = a1;
        !           323:                }
        !           324:                if (lastsep==';')
        !           325:                        addr1 = a1;
        !           326:                printcom();
        !           327:                continue;
        !           328: 
        !           329:        case 'l':
        !           330:                listf++;
        !           331:        case 'p':
        !           332:        case 'P':
        !           333:                newline();
        !           334:                printcom();
        !           335:                continue;
        !           336: 
        !           337:        case 'Q':
        !           338:                fchange = 0;
        !           339:        case 'q':
        !           340:                setnoaddr();
        !           341:                newline();
        !           342:                quit();
        !           343: 
        !           344:        case 'r':
        !           345:                filename(c);
        !           346:        caseread:
        !           347:                if ((io = open(file, O_RDONLY)) < 0) {
        !           348:                        lastc = '\n';
        !           349:                        error(file);
        !           350:                }
        !           351:                setwide();
        !           352:                squeeze(0);
        !           353:                ninbuf = 0;
        !           354:                c = zero != dol;
        !           355:                append(getfile, addr2);
        !           356:                exfile();
        !           357:                fchange = c;
        !           358:                continue;
        !           359: 
        !           360:        case 's':
        !           361:                nonzero();
        !           362:                substitute(globp!=0);
        !           363:                continue;
        !           364: 
        !           365:        case 't':
        !           366:                move(1);
        !           367:                continue;
        !           368: 
        !           369:        case 'u':
        !           370:                nonzero();
        !           371:                newline();
        !           372:                if ((*addr2&~01) != subnewa)
        !           373:                        error(Q);
        !           374:                *addr2 = subolda;
        !           375:                dot = addr2;
        !           376:                continue;
        !           377: 
        !           378:        case 'v':
        !           379:                global(0);
        !           380:                continue;
        !           381: 
        !           382:        case 'W':
        !           383:                wrapp++;
        !           384:        case 'w':
        !           385:                setwide();
        !           386:                squeeze(dol>zero);
        !           387:                if ((temp = getchr()) != 'q' && temp != 'Q') {
        !           388:                        peekc = temp;
        !           389:                        temp = 0;
        !           390:                }
        !           391:                filename(c);
        !           392:                if(!wrapp ||
        !           393:                  ((io = open(file, O_WRONLY)) == -1) ||
        !           394:                  ((lseek(io, 0L, SEEK_END)) == -1))
        !           395:                        if ((io = creat(file, 0666)) == -1)
        !           396:                                error(file);
        !           397:                wrapp = 0;
        !           398:                if (dol > zero)
        !           399:                        putfile();
        !           400:                exfile();
        !           401:                if (addr1<=zero+1 && addr2==dol)
        !           402:                        fchange = 0;
        !           403:                if (temp == 'Q')
        !           404:                        fchange = 0;
        !           405:                if (temp)
        !           406:                        quit();
        !           407:                continue;
        !           408: 
        !           409:        case '=':
        !           410:                setwide();
        !           411:                squeeze(0);
        !           412:                newline();
        !           413:                count = addr2 - zero;
        !           414:                putd();
        !           415:                putchr('\n');
        !           416:                continue;
        !           417: 
        !           418:        case '!':
        !           419:                callunix();
        !           420:                continue;
        !           421: 
        !           422:        case EOF:
        !           423:                return;
        !           424: 
        !           425:        }
        !           426:        error(Q);
        !           427:        }
        !           428: }
        !           429: 
        !           430: void
        !           431: printcom(void)
        !           432: {
        !           433:        int *a1;
        !           434: 
        !           435:        nonzero();
        !           436:        a1 = addr1;
        !           437:        do {
        !           438:                if (listn) {
        !           439:                        count = a1-zero;
        !           440:                        putd();
        !           441:                        putchr('\t');
        !           442:                }
        !           443:                putshst(getline(*a1++));
        !           444:        } while (a1 <= addr2);
        !           445:        dot = addr2;
        !           446:        listf = 0;
        !           447:        listn = 0;
        !           448:        pflag = 0;
        !           449: }
        !           450: 
        !           451: int*
        !           452: address(void)
        !           453: {
        !           454:        int sign, *a, opcnt, nextopand, *b, c;
        !           455: 
        !           456:        nextopand = -1;
        !           457:        sign = 1;
        !           458:        opcnt = 0;
        !           459:        a = dot;
        !           460:        do {
        !           461:                do c = getchr(); while (c==' ' || c=='\t');
        !           462:                if ('0'<=c && c<='9') {
        !           463:                        peekc = c;
        !           464:                        if (!opcnt)
        !           465:                                a = zero;
        !           466:                        a += sign*getnum();
        !           467:                } else switch (c) {
        !           468:                case '$':
        !           469:                        a = dol;
        !           470:                        /* fall through */
        !           471:                case '.':
        !           472:                        if (opcnt)
        !           473:                                error(Q);
        !           474:                        break;
        !           475:                case '\'':
        !           476:                        c = getchr();
        !           477:                        if (opcnt || c<'a' || 'z'<c)
        !           478:                                error(Q);
        !           479:                        a = zero;
        !           480:                        do a++; while (a<=dol && names[c-'a']!=(*a&~01));
        !           481:                        break;
        !           482:                case '?':
        !           483:                        sign = -sign;
        !           484:                        /* fall through */
        !           485:                case '/':
        !           486:                        compile(c);
        !           487:                        b = a;
        !           488:                        for (;;) {
        !           489:                                a += sign;
        !           490:                                if (a<=zero)
        !           491:                                        a = dol;
        !           492:                                if (a>dol)
        !           493:                                        a = zero;
        !           494:                                if (execute(a))
        !           495:                                        break;
        !           496:                                if (a==b)
        !           497:                                        error(Q);
        !           498:                        }
        !           499:                        break;
        !           500:                default:
        !           501:                        if (nextopand == opcnt) {
        !           502:                                a += sign;
        !           503:                                if (a<zero || dol<a)
        !           504:                                        continue;       /* error(Q); */
        !           505:                        }
        !           506:                        if (c!='+' && c!='-' && c!='^') {
        !           507:                                peekc = c;
        !           508:                                if (opcnt==0)
        !           509:                                        a = 0;
        !           510:                                return a;
        !           511:                        }
        !           512:                        sign = 1;
        !           513:                        if (c!='+')
        !           514:                                sign = -sign;
        !           515:                        nextopand = ++opcnt;
        !           516:                        continue;
        !           517:                }
        !           518:                sign = 1;
        !           519:                opcnt++;
        !           520:        } while (zero<=a && a<=dol);
        !           521:        error(Q);
        !           522:        return 0;
        !           523: }
        !           524: 
        !           525: getnum(void)
        !           526: {
        !           527:        int r, c;
        !           528: 
        !           529:        r = 0;
        !           530:        while ((c=getchr())>='0' && c<='9')
        !           531:                r = r*10 + c - '0';
        !           532:        peekc = c;
        !           533:        return r;
        !           534: }
        !           535: 
        !           536: void
        !           537: setwide(void)
        !           538: {
        !           539:        if (!given) {
        !           540:                addr1 = zero + (dol>zero);
        !           541:                addr2 = dol;
        !           542:        }
        !           543: }
        !           544: 
        !           545: void
        !           546: setnoaddr(void)
        !           547: {
        !           548:        if (given)
        !           549:                error(Q);
        !           550: }
        !           551: 
        !           552: void
        !           553: nonzero(void)
        !           554: {
        !           555:        squeeze(1);
        !           556: }
        !           557: 
        !           558: void
        !           559: squeeze(int i)
        !           560: {
        !           561:        if (addr1<zero+i || addr2>dol || addr1>addr2)
        !           562:                error(Q);
        !           563: }
        !           564: 
        !           565: void
        !           566: newline(void)
        !           567: {
        !           568:        int c;
        !           569: 
        !           570:        if ((c = getchr()) == '\n' || c == EOF)
        !           571:                return;
        !           572:        if (c=='p' || c=='l' || c=='n') {
        !           573:                pflag++;
        !           574:                if (c=='l')
        !           575:                        listf++;
        !           576:                else if (c=='n')
        !           577:                        listn++;
        !           578:                if (getchr()=='\n')
        !           579:                        return;
        !           580:        }
        !           581:        error(Q);
        !           582: }
        !           583: 
        !           584: void
        !           585: filename(int comm)
        !           586: {
        !           587:        char *p1, *p2;
        !           588:        int c;
        !           589: 
        !           590:        count = 0;
        !           591:        c = getchr();
        !           592:        if (c=='\n' || c==EOF) {
        !           593:                p1 = savedfile;
        !           594:                if (*p1==0 && comm!='f')
        !           595:                        error(Q);
        !           596:                p2 = file;
        !           597:                while (*p2++ = *p1++)
        !           598:                        ;
        !           599:                return;
        !           600:        }
        !           601:        if (c!=' ')
        !           602:                error(Q);
        !           603:        while ((c = getchr()) == ' ')
        !           604:                ;
        !           605:        if (c=='\n')
        !           606:                error(Q);
        !           607:        p1 = file;
        !           608:        do {
        !           609:                if (p1 >= &file[sizeof(file)-1] || c==' ' || c==EOF)
        !           610:                        error(Q);
        !           611:                *p1++ = c;
        !           612:        } while ((c = getchr()) != '\n');
        !           613:        *p1++ = 0;
        !           614:        if (savedfile[0]==0 || comm=='e' || comm=='f') {
        !           615:                p1 = savedfile;
        !           616:                p2 = file;
        !           617:                while (*p1++ = *p2++)
        !           618:                        ;
        !           619:        }
        !           620: }
        !           621: 
        !           622: void
        !           623: exfile(void)
        !           624: {
        !           625:        close(io);
        !           626:        io = -1;
        !           627:        if (vflag) {
        !           628:                putd();
        !           629:                putchr('\n');
        !           630:        }
        !           631: }
        !           632: 
        !           633: void
        !           634: onintr(int sig)
        !           635: {
        !           636: #pragma ref sig
        !           637:        signal(SIGINT, onintr);
        !           638:        putchr('\n');
        !           639:        lastc = '\n';
        !           640:        error(Q);
        !           641: }
        !           642: 
        !           643: void
        !           644: onhup(int sig)
        !           645: {
        !           646: #pragma ref sig
        !           647:        signal(SIGINT, SIG_IGN);
        !           648:        signal(SIGHUP, SIG_IGN);
        !           649:        if (dol > zero) {
        !           650:                addr1 = zero+1;
        !           651:                addr2 = dol;
        !           652:                io = creat("ed.hup", 0600);
        !           653:                if (io > 0)
        !           654:                        putfile();
        !           655:        }
        !           656:        fchange = 0;
        !           657:        quit();
        !           658: }
        !           659: 
        !           660: void
        !           661: error(char *s)
        !           662: {
        !           663:        int c;
        !           664: 
        !           665:        wrapp = 0;
        !           666:        listf = 0;
        !           667:        listn = 0;
        !           668:        count = 0;
        !           669:        lseek(0, 0, SEEK_END);
        !           670:        pflag = 0;
        !           671:        if (globp)
        !           672:                lastc = '\n';
        !           673:        globp = 0;
        !           674:        peekc = lastc;
        !           675:        if(lastc)
        !           676:                while ((c = getchr()) != '\n' && c != EOF)
        !           677:                        ;
        !           678:        if (io > 0) {
        !           679:                close(io);
        !           680:                io = -1;
        !           681:        }
        !           682:        putchr('?');
        !           683:        putst(s);
        !           684:        longjmp(savej, 1);
        !           685: }
        !           686: 
        !           687: getchr(void)
        !           688: {
        !           689:        unsigned char c;
        !           690: 
        !           691:        if (lastc = peekc) {
        !           692:                peekc = 0;
        !           693:                return lastc;
        !           694:        }
        !           695:        if (globp) {
        !           696:                if ((lastc = *globp++) != 0)
        !           697:                        return lastc;
        !           698:                globp = 0;
        !           699:                return EOF;
        !           700:        }
        !           701:        if (read(0, (char *)&c, 1) <= 0)
        !           702:                return lastc = EOF;
        !           703:        lastc = c;
        !           704:        return lastc;
        !           705: }
        !           706: 
        !           707: gety(void)
        !           708: {
        !           709:        int c;
        !           710:        char *gf;
        !           711:        short *p;
        !           712: 
        !           713:        p = linebuf;
        !           714:        gf = globp;
        !           715:        while ((c = getchr()) != '\n') {
        !           716:                if (c==EOF) {
        !           717:                        if (gf)
        !           718:                                peekc = c;
        !           719:                        return c;
        !           720:                }
        !           721:                if (c == 0)
        !           722:                        continue;
        !           723:                *p++ = c;
        !           724:                if (p >= &linebuf[LBSIZE-2])
        !           725:                        error(Q);
        !           726:        }
        !           727: 
        !           728:        *p = 0;
        !           729:        return 0;
        !           730: }
        !           731: 
        !           732: gettty(void)
        !           733: {
        !           734:        int rc;
        !           735: 
        !           736:        if (rc = gety())
        !           737:                return rc;
        !           738:        if (linebuf[0]=='.' && linebuf[1]==0)
        !           739:                return EOF;
        !           740:        return 0;
        !           741: }
        !           742: 
        !           743: getfile(void)
        !           744: {
        !           745:        int c;
        !           746:        char *fp;
        !           747:        short *lp;
        !           748: 
        !           749:        lp = linebuf;
        !           750:        fp = nextip;
        !           751:        do {
        !           752:                if (--ninbuf < 0) {
        !           753:                        if ((ninbuf = read(io, iobuf, LBSIZE)-1) < 0)
        !           754:                                if (lp>linebuf) {
        !           755:                                        putst("'\\n' appended");
        !           756:                                        *iobuf = '\n';
        !           757:                                } else
        !           758:                                        return EOF;
        !           759:                        fp = iobuf;
        !           760:                }
        !           761:                c = *fp++;
        !           762:                if (c == '\0')
        !           763:                        continue;
        !           764:                if (lp >= &linebuf[LBSIZE]) {
        !           765:                        lastc = '\n';
        !           766:                        error(Q);
        !           767:                }
        !           768:                *lp++ = c;
        !           769:                count++;
        !           770:        } while (c != '\n');
        !           771:        *--lp = 0;
        !           772:        nextip = fp;
        !           773:        return 0;
        !           774: }
        !           775: 
        !           776: void
        !           777: putfile(void)
        !           778: {
        !           779:        int *a1, n, nib;
        !           780:        char *fp;
        !           781:        short *lp;
        !           782: 
        !           783:        nib = BLKSIZE;
        !           784:        fp = iobuf;
        !           785:        a1 = addr1;
        !           786:        do {
        !           787:                lp = getline(*a1++);
        !           788:                for (;;) {
        !           789:                        if (--nib < 0) {
        !           790:                                n = fp-iobuf;
        !           791:                                if(write(io, iobuf, n) != n) {
        !           792:                                        putst(WRERR);
        !           793:                                        error(Q);
        !           794:                                }
        !           795:                                nib = BLKSIZE-1;
        !           796:                                fp = iobuf;
        !           797:                        }
        !           798:                        count++;
        !           799:                        if ((*fp++ = *lp++) == 0) {
        !           800:                                fp[-1] = '\n';
        !           801:                                break;
        !           802:                        }
        !           803:                }
        !           804:        } while (a1 <= addr2);
        !           805:        n = fp-iobuf;
        !           806:        if(write(io, iobuf, n) != n) {
        !           807:                putst(WRERR);
        !           808:                error(Q);
        !           809:        }
        !           810: }
        !           811: 
        !           812: append(int (*f)(void), int *a)
        !           813: {
        !           814:        int *a1, *a2, *rdot, nline, tl;
        !           815: 
        !           816:        nline = 0;
        !           817:        dot = a;
        !           818:        while ((*f)() == 0) {
        !           819:                if ((dol-zero)+1 >= nlall) {
        !           820:                        int *ozero = zero;
        !           821:                        nlall += 1024;
        !           822:                        if ((zero = (int *)realloc((char *)zero, nlall*sizeof(int)))==NULL) {
        !           823:                                error("MEM?");
        !           824:                                onhup(0);
        !           825:                        }
        !           826:                        dot += zero - ozero;
        !           827:                        dol += zero - ozero;
        !           828:                }
        !           829:                tl = putline();
        !           830:                nline++;
        !           831:                a1 = ++dol;
        !           832:                a2 = a1+1;
        !           833:                rdot = ++dot;
        !           834:                while (a1 > rdot)
        !           835:                        *--a2 = *--a1;
        !           836:                *rdot = tl;
        !           837:        }
        !           838:        return nline;
        !           839: }
        !           840: 
        !           841: void
        !           842: add(int i)
        !           843: {
        !           844:        if (i && (given || dol>zero)) {
        !           845:                addr1--;
        !           846:                addr2--;
        !           847:        }
        !           848:        squeeze(0);
        !           849:        newline();
        !           850:        append(gettty, addr2);
        !           851: }
        !           852: 
        !           853: void
        !           854: browse(void)
        !           855: {
        !           856:        int forward, n;
        !           857:        static bformat, bnum; /* 0 */
        !           858: 
        !           859:        forward = 1;
        !           860:        if((peekc=getchr()) != '\n'){
        !           861:                if (peekc=='-' || peekc=='+') {
        !           862:                        if(peekc == '-')
        !           863:                                forward=0;
        !           864:                        getchr();
        !           865:                }
        !           866:                if((n=getnum()) > 0)
        !           867:                        bpagesize = n;
        !           868:        }
        !           869:        newline();
        !           870:        if (pflag) {
        !           871:                bformat = listf;
        !           872:                bnum = listn;
        !           873:        } else {
        !           874:                listf = bformat;
        !           875:                listn = bnum;
        !           876:        }
        !           877:        if (forward) {
        !           878:                addr1 = addr2;
        !           879:                if((addr2+=bpagesize) > dol)
        !           880:                        addr2 = dol;
        !           881:        } else {
        !           882:                if((addr1=addr2-bpagesize) <= zero)
        !           883:                        addr1 = zero+1;
        !           884:        }
        !           885:        printcom();
        !           886: }
        !           887: 
        !           888: void
        !           889: callunix(void)
        !           890: {
        !           891:        pid_t pid, rpid;
        !           892:        void (*savint)(int);
        !           893:        int retcode;
        !           894: 
        !           895:        setnoaddr();
        !           896:        if ((pid = fork()) == 0) {
        !           897:                signal(SIGHUP, oldhup);
        !           898:                signal(SIGQUIT, oldquit);
        !           899:                execl("/bin/sh", "sh", "-t", 0);
        !           900:                exit(0100);
        !           901:        }
        !           902:        savint = signal(SIGINT, SIG_IGN);
        !           903:        while ((rpid = wait(&retcode)) != pid && rpid != -1)
        !           904:                ;
        !           905:        signal(SIGINT, savint);
        !           906:        if (vflag) {
        !           907:                putst("!");
        !           908:        }
        !           909: }
        !           910: 
        !           911: void
        !           912: quit(void)
        !           913: {
        !           914:        if (vflag && fchange && dol!=zero) {
        !           915:                fchange = 0;
        !           916:                error(Q);
        !           917:        }
        !           918:        remove(tfname);
        !           919:        exit(0);
        !           920: }
        !           921: 
        !           922: void
        !           923: onquit(int sig)
        !           924: {
        !           925: #pragma ref sig
        !           926:        quit();
        !           927: }
        !           928: 
        !           929: void
        !           930: rdelete(int *ad1, int *ad2)
        !           931: {
        !           932:        int *a1, *a2, *a3;
        !           933: 
        !           934:        a1 = ad1;
        !           935:        a2 = ad2+1;
        !           936:        a3 = dol;
        !           937:        dol -= a2 - a1;
        !           938:        do {
        !           939:                *a1++ = *a2++;
        !           940:        } while (a2 <= a3);
        !           941:        a1 = ad1;
        !           942:        if (a1 > dol)
        !           943:                a1 = dol;
        !           944:        dot = a1;
        !           945:        fchange = 1;
        !           946: }
        !           947: 
        !           948: void
        !           949: gdelete(void)
        !           950: {
        !           951:        int *a1, *a2, *a3;
        !           952: 
        !           953:        a3 = dol;
        !           954:        for (a1=zero; (*a1&01)==0; a1++)
        !           955:                if (a1>=a3)
        !           956:                        return;
        !           957:        for (a2=a1+1; a2<=a3;) {
        !           958:                if (*a2&01) {
        !           959:                        a2++;
        !           960:                        dot = a1;
        !           961:                } else
        !           962:                        *a1++ = *a2++;
        !           963:        }
        !           964:        dol = a1-1;
        !           965:        if (dot>dol)
        !           966:                dot = dol;
        !           967:        fchange = 1;
        !           968: }
        !           969: 
        !           970: short*
        !           971: getline(int tl)
        !           972: {
        !           973:        unsigned char *bp;
        !           974:        short *lp;
        !           975:        int nl;
        !           976: 
        !           977:        lp = linebuf;
        !           978:        bp = getblock(tl, READ);
        !           979:        nl = nleft;
        !           980:        tl &= ~((BLKSIZE/2)-1);
        !           981:        while (*lp++ = *bp++)
        !           982:                if (--nl == 0) {
        !           983:                        bp = getblock(tl+=(BLKSIZE/2), READ);
        !           984:                        nl = nleft;
        !           985:                }
        !           986:        return linebuf;
        !           987: }
        !           988: 
        !           989: putline(void)
        !           990: {
        !           991:        unsigned char *bp;
        !           992:        short *lp;
        !           993:        int nl, tl;
        !           994: 
        !           995:        fchange = 1;
        !           996:        lp = linebuf;
        !           997:        tl = tline;
        !           998:        bp = getblock(tl, WRITE);
        !           999:        nl = nleft;
        !          1000:        tl &= ~((BLKSIZE/2)-1);
        !          1001:        while (*bp = *lp++) {
        !          1002:                if (*bp++ == '\n') {
        !          1003:                        *--bp = 0;
        !          1004:                        linebp = lp;
        !          1005:                        break;
        !          1006:                }
        !          1007:                if (--nl == 0) {
        !          1008:                        bp = getblock(tl+=(BLKSIZE/2), WRITE);
        !          1009:                        nl = nleft;
        !          1010:                }
        !          1011:        }
        !          1012:        nl = tline;
        !          1013:        tline += (((lp-linebuf)+03)>>1)&077776;
        !          1014:        return nl;
        !          1015: }
        !          1016: 
        !          1017: void
        !          1018: blkio(int b, unsigned char *buf, int (*iofcn)(int, char *, unsigned))
        !          1019: {
        !          1020:        lseek(tfile, b*BLKSIZE, SEEK_SET);
        !          1021:        if ((*iofcn)(tfile, (char *)buf, BLKSIZE) != BLKSIZE) {
        !          1022:                error(T);
        !          1023:        }
        !          1024: }
        !          1025: 
        !          1026: unsigned char *
        !          1027: getblock(int atl, int iof)
        !          1028: {
        !          1029:        int bno, off;
        !          1030:        
        !          1031:        bno = (atl/(BLKSIZE/2));
        !          1032:        off = (atl<<1) & (BLKSIZE-1) & ~03;
        !          1033:        if (bno >= NBLK) {
        !          1034:                lastc = '\n';
        !          1035:                error(T);
        !          1036:        }
        !          1037:        nleft = BLKSIZE - off;
        !          1038:        if (bno==iblock) {
        !          1039:                ichanged |= iof;
        !          1040:                return ibuff+off;
        !          1041:        }
        !          1042:        if (bno==oblock)
        !          1043:                return obuff+off;
        !          1044:        if (iof==READ) {
        !          1045:                if (ichanged)
        !          1046:                        blkio(iblock, ibuff, write);
        !          1047:                ichanged = 0;
        !          1048:                iblock = bno;
        !          1049:                blkio(bno, ibuff, read);
        !          1050:                return ibuff+off;
        !          1051:        }
        !          1052:        if (oblock>=0)
        !          1053:                blkio(oblock, obuff, write);
        !          1054:        oblock = bno;
        !          1055:        return obuff+off;
        !          1056: }
        !          1057: 
        !          1058: void
        !          1059: init(void)
        !          1060: {
        !          1061:        int *markp;
        !          1062: 
        !          1063:        close(tfile);
        !          1064:        tline = 2;
        !          1065:        for (markp = names; markp < &names[26]; )
        !          1066:                *markp++ = 0;
        !          1067:        subnewa = 0;
        !          1068:        anymarks = 0;
        !          1069:        iblock = -1;
        !          1070:        oblock = -1;
        !          1071:        ichanged = 0;
        !          1072:        close(creat(tfname, 0600));
        !          1073:        tfile = open(tfname, O_RDWR);
        !          1074:        dot = dol = zero;
        !          1075: }
        !          1076: 
        !          1077: void
        !          1078: global(int k)
        !          1079: {
        !          1080:        char *gp, globuf[GBSIZE];
        !          1081:        int c, *a1;
        !          1082: 
        !          1083:        if (globp)
        !          1084:                error(Q);
        !          1085:        setwide();
        !          1086:        squeeze(dol>zero);
        !          1087:        if ((c=getchr())=='\n')
        !          1088:                error(Q);
        !          1089:        compile(c);
        !          1090:        gp = globuf;
        !          1091:        while ((c = getchr()) != '\n') {
        !          1092:                if (c==EOF)
        !          1093:                        error(Q);
        !          1094:                if (c=='\\') {
        !          1095:                        c = getchr();
        !          1096:                        if (c!='\n')
        !          1097:                                *gp++ = '\\';
        !          1098:                }
        !          1099:                *gp++ = c;
        !          1100:                if (gp >= &globuf[GBSIZE-2])
        !          1101:                        error(Q);
        !          1102:        }
        !          1103:        if (gp == globuf)
        !          1104:                *gp++ = 'p';
        !          1105:        *gp++ = '\n';
        !          1106:        *gp = 0;
        !          1107:        for (a1=zero; a1<=dol; a1++) {
        !          1108:                *a1 &= ~01;
        !          1109:                if (a1>=addr1 && a1<=addr2 && execute(a1)==k)
        !          1110:                        *a1 |= 01;
        !          1111:        }
        !          1112:        /*
        !          1113:         * Special case: g/.../d (avoid n^2 algorithm)
        !          1114:         */
        !          1115:        if (globuf[0]=='d' && globuf[1]=='\n' && globuf[2]=='\0') {
        !          1116:                gdelete();
        !          1117:                return;
        !          1118:        }
        !          1119:        for (a1=zero; a1<=dol; a1++) {
        !          1120:                if (*a1 & 01) {
        !          1121:                        *a1 &= ~01;
        !          1122:                        dot = a1;
        !          1123:                        globp = globuf;
        !          1124:                        commands();
        !          1125:                        a1 = zero;
        !          1126:                }
        !          1127:        }
        !          1128: }
        !          1129: 
        !          1130: void
        !          1131: join(void)
        !          1132: {
        !          1133:        short *gp, *lp;
        !          1134:        int *a1;
        !          1135: 
        !          1136:        nonzero();
        !          1137:        gp = genbuf;
        !          1138:        for (a1=addr1; a1<=addr2; a1++) {
        !          1139:                lp = getline(*a1);
        !          1140:                while (*gp = *lp++)
        !          1141:                        if (gp++ >= &genbuf[LBSIZE-2])
        !          1142:                                error(Q);
        !          1143:        }
        !          1144:        lp = linebuf;
        !          1145:        gp = genbuf;
        !          1146:        while (*lp++ = *gp++)
        !          1147:                ;
        !          1148:        *addr1 = putline();
        !          1149:        if (addr1 < addr2)
        !          1150:                rdelete(addr1+1, addr2);
        !          1151:        dot = addr1;
        !          1152: }
        !          1153: 
        !          1154: void
        !          1155: substitute(int inglob)
        !          1156: {
        !          1157:        int *mp, *a1, nl, gsubf, n;
        !          1158: 
        !          1159:        n = getnum();   /* OK even if n==0 */
        !          1160:        gsubf = compsub();
        !          1161:        for (a1 = addr1; a1 <= addr2; a1++) {
        !          1162:                if (execute(a1)){
        !          1163:                        int *ozero;
        !          1164:                        int m = n;
        !          1165: 
        !          1166:                        do {
        !          1167:                                int span = loc2-loc1;
        !          1168: 
        !          1169:                                if (--m <= 0) {
        !          1170:                                        dosub();
        !          1171:                                        if (!gsubf)
        !          1172:                                                break;
        !          1173:                                        if (span == 0) {        /* null RE match */
        !          1174:                                                if (*loc2=='\0')
        !          1175:                                                        break;
        !          1176:                                                loc2++;
        !          1177:                                        }
        !          1178:                                }
        !          1179:                        } while (execute((int*)0));
        !          1180:                        if (m <= 0) {
        !          1181:                                inglob |= 01;
        !          1182:                                subnewa = putline();
        !          1183:                                *a1 &= ~01;
        !          1184:                                if (anymarks) {
        !          1185:                                        for (mp = names; mp < &names[26]; mp++)
        !          1186:                                                if (*mp == *a1)
        !          1187:                                                        *mp = subnewa;
        !          1188:                                }
        !          1189:                                subolda = *a1;
        !          1190:                                *a1 = subnewa;
        !          1191:                                ozero = zero;
        !          1192:                                nl = append(getsub, a1);
        !          1193:                                nl += zero-ozero;
        !          1194:                                a1 += nl;
        !          1195:                                addr2 += nl;
        !          1196:                        }
        !          1197:                }
        !          1198:        }
        !          1199:        if (inglob==0)
        !          1200:                error(Q);
        !          1201: }
        !          1202: 
        !          1203: compsub(void)
        !          1204: {
        !          1205:        int seof, c;
        !          1206:        short *p;
        !          1207: 
        !          1208:        if ((seof = getchr()) == '\n' || seof == ' ')
        !          1209:                error(Q);
        !          1210:        compile(seof);
        !          1211:        p = rhsbuf;
        !          1212:        for (;;) {
        !          1213:                c = getchr();
        !          1214:                if (c=='\\')
        !          1215:                        c = getchr() | 0x100;
        !          1216:                if (c=='\n') {
        !          1217:                        if (globp && globp[0])  /* last '\n' does not count */
        !          1218:                                c |= 0x100;
        !          1219:                        else {
        !          1220:                                peekc = c;
        !          1221:                                pflag++;
        !          1222:                                break;
        !          1223:                        }
        !          1224:                }
        !          1225:                if (c == seof)
        !          1226:                        break;
        !          1227:                *p++ = c;
        !          1228:                if (p >= &rhsbuf[LBSIZE/2])
        !          1229:                        error(Q);
        !          1230:        }
        !          1231:        *p = 0;
        !          1232:        if ((peekc = getchr()) == 'g') {
        !          1233:                peekc = 0;
        !          1234:                newline();
        !          1235:                return 1;
        !          1236:        }
        !          1237:        newline();
        !          1238:        return 0;
        !          1239: }
        !          1240: 
        !          1241: getsub(void)
        !          1242: {
        !          1243:        short *p1, *p2;
        !          1244: 
        !          1245:        p1 = linebuf;
        !          1246:        if ((p2 = linebp) == 0)
        !          1247:                return EOF;
        !          1248:        while (*p1++ = *p2++)
        !          1249:                ;
        !          1250:        linebp = 0;
        !          1251:        return 0;
        !          1252: }
        !          1253: 
        !          1254: void
        !          1255: dosub(void)
        !          1256: {
        !          1257:        short *lp, *sp, *rp;
        !          1258:        int c;
        !          1259: 
        !          1260:        lp = linebuf;
        !          1261:        sp = genbuf;
        !          1262:        rp = rhsbuf;
        !          1263:        while (lp < loc1)
        !          1264:                *sp++ = *lp++;
        !          1265:        while (c = *rp++) {
        !          1266:                if (c=='&') {
        !          1267:                        sp = place(sp, loc1, loc2);
        !          1268:                        continue;
        !          1269:                } else if (c&0x100 && (c &= 0xFF) >='1' && c < nbra+'1') {
        !          1270:                        sp = place(sp, braslist[c-'1'], braelist[c-'1']);
        !          1271:                        continue;
        !          1272:                }
        !          1273:                *sp++ = c&0xFF;
        !          1274:                if (sp >= &genbuf[LBSIZE])
        !          1275:                        error(Q);
        !          1276:        }
        !          1277:        lp = loc2;
        !          1278:        loc2 = sp - genbuf + linebuf;
        !          1279:        while (*sp++ = *lp++)
        !          1280:                if (sp >= &genbuf[LBSIZE])
        !          1281:                        error(Q);
        !          1282:        lp = linebuf;
        !          1283:        sp = genbuf;
        !          1284:        while (*lp++ = *sp++)
        !          1285:                ;
        !          1286: }
        !          1287: 
        !          1288: short*
        !          1289: place(short *sp, short *l1, short *l2)
        !          1290: {
        !          1291: 
        !          1292:        while (l1 < l2) {
        !          1293:                *sp++ = *l1++;
        !          1294:                if (sp >= &genbuf[LBSIZE])
        !          1295:                        error(Q);
        !          1296:        }
        !          1297:        return sp;
        !          1298: }
        !          1299: 
        !          1300: void
        !          1301: move(int cflag)
        !          1302: {
        !          1303:        int *adt, *ad1, *ad2;
        !          1304: 
        !          1305:        nonzero();
        !          1306:        if ((adt = address())==0)       /* address() guarantees addr is in range */
        !          1307:                error(Q);
        !          1308:        newline();
        !          1309:        if (cflag) {
        !          1310:                int *ozero, delta;
        !          1311:                ad1 = dol;
        !          1312:                ozero = zero;
        !          1313:                append(getcopy, ad1++);
        !          1314:                ad2 = dol;
        !          1315:                delta = zero - ozero;
        !          1316:                ad1 += delta;
        !          1317:                adt += delta;
        !          1318:        } else {
        !          1319:                ad2 = addr2;
        !          1320:                for (ad1 = addr1; ad1 <= ad2;)
        !          1321:                        *ad1++ &= ~01;
        !          1322:                ad1 = addr1;
        !          1323:        }
        !          1324:        ad2++;
        !          1325:        if (adt<ad1) {
        !          1326:                dot = adt + (ad2-ad1);
        !          1327:                if ((++adt)==ad1)
        !          1328:                        return;
        !          1329:                reverse(adt, ad1);
        !          1330:                reverse(ad1, ad2);
        !          1331:                reverse(adt, ad2);
        !          1332:        } else if (adt >= ad2) {
        !          1333:                dot = adt++;
        !          1334:                reverse(ad1, ad2);
        !          1335:                reverse(ad2, adt);
        !          1336:                reverse(ad1, adt);
        !          1337:        } else
        !          1338:                error(Q);
        !          1339:        fchange = 1;
        !          1340: }
        !          1341: 
        !          1342: void
        !          1343: reverse(int *a1, int *a2)
        !          1344: {
        !          1345:        int t;
        !          1346: 
        !          1347:        for (;;) {
        !          1348:                t = *--a2;
        !          1349:                if (a2 <= a1)
        !          1350:                        return;
        !          1351:                *a2 = *a1;
        !          1352:                *a1++ = t;
        !          1353:        }
        !          1354: }
        !          1355: 
        !          1356: getcopy(void)
        !          1357: {
        !          1358:        if (addr1 > addr2)
        !          1359:                return EOF;
        !          1360:        getline(*addr1++);
        !          1361:        return 0;
        !          1362: }
        !          1363: 
        !          1364: void
        !          1365: compile(int eof)
        !          1366: {
        !          1367:        int c, cclcnt;
        !          1368:        short *ep, *lastep, bracket[NBRA], *bracketp;
        !          1369: 
        !          1370:        ep = expbuf;
        !          1371:        bracketp = bracket;
        !          1372:        if ((c = getchr()) == '\n') {
        !          1373:                peekc = c;
        !          1374:                c = eof;
        !          1375:        }
        !          1376:        if (c == eof) {
        !          1377:                if (*ep==0)
        !          1378:                        error(Q);
        !          1379:                return;
        !          1380:        }
        !          1381:        nbra = 0;
        !          1382:        if (c=='^') {
        !          1383:                c = getchr();
        !          1384:                *ep++ = CCIRC;
        !          1385:        }
        !          1386:        peekc = c;
        !          1387:        lastep = 0;
        !          1388:        for (;;) {
        !          1389:                if (ep >= &expbuf[ESIZE])
        !          1390:                        goto cerror;
        !          1391:                c = getchr();
        !          1392:                if (c == '\n') {
        !          1393:                        peekc = c;
        !          1394:                        c = eof;
        !          1395:                }
        !          1396:                if (c==eof) {
        !          1397:                        if (bracketp != bracket)
        !          1398:                                goto cerror;
        !          1399:                        *ep = CEFIL;
        !          1400:                        return;
        !          1401:                }
        !          1402:                if (c!='*')
        !          1403:                        lastep = ep;
        !          1404:                switch (c) {
        !          1405: 
        !          1406:                case '\\':
        !          1407:                        if ((c = getchr())=='(') {
        !          1408:                                if (nbra >= NBRA)
        !          1409:                                        goto cerror;
        !          1410:                                *bracketp++ = nbra;
        !          1411:                                *ep++ = CBRA;
        !          1412:                                *ep++ = nbra++;
        !          1413:                                continue;
        !          1414:                        }
        !          1415:                        if (c == ')') {
        !          1416:                                if (bracketp <= bracket)
        !          1417:                                        goto cerror;
        !          1418:                                *ep++ = CKET;
        !          1419:                                *ep++ = *--bracketp;
        !          1420:                                continue;
        !          1421:                        }
        !          1422:                        if (c>='1' && c<'1'+NBRA) {
        !          1423:                                *ep++ = CBACK;
        !          1424:                                *ep++ = c-'1';
        !          1425:                                continue;
        !          1426:                        }
        !          1427:                        *ep++ = CCHR;
        !          1428:                        if (c=='\n')
        !          1429:                                goto cerror;
        !          1430:                        *ep++ = c;
        !          1431:                        continue;
        !          1432: 
        !          1433:                case '.':
        !          1434:                        *ep++ = CDOT;
        !          1435:                        continue;
        !          1436: 
        !          1437:                case '\n':
        !          1438:                        goto cerror;
        !          1439: 
        !          1440:                case '*':
        !          1441:                        if (lastep==0 || *lastep==CBRA || *lastep==CKET)
        !          1442:                                goto defchar;
        !          1443:                        *lastep |= STAR;
        !          1444:                        continue;
        !          1445: 
        !          1446:                case '$':
        !          1447:                        if ((peekc=getchr()) != eof && peekc!='\n')
        !          1448:                                goto defchar;
        !          1449:                        *ep++ = CDOL;
        !          1450:                        continue;
        !          1451: 
        !          1452:                case '[':
        !          1453:                        *ep++ = CCL;
        !          1454:                        *ep++ = 0;
        !          1455:                        cclcnt = 1;
        !          1456:                        if ((c=getchr()) == '^') {
        !          1457:                                c = getchr();
        !          1458:                                ep[-2] = NCCL;
        !          1459:                        }
        !          1460:                        do {
        !          1461:                                if (c=='\n')
        !          1462:                                        goto cerror;
        !          1463:                                if (c=='-' && ep[-1]!=0) {
        !          1464:                                        if ((c=getchr())==']') {
        !          1465:                                                *ep++ = '-';
        !          1466:                                                cclcnt++;
        !          1467:                                                break;
        !          1468:                                        }
        !          1469:                                        while (ep[-1]<c) {
        !          1470:                                                *ep = ep[-1]+1;
        !          1471:                                                ep++;
        !          1472:                                                cclcnt++;
        !          1473:                                                if (ep>=&expbuf[ESIZE])
        !          1474:                                                        goto cerror;
        !          1475:                                        }
        !          1476:                                }
        !          1477:                                *ep++ = c;
        !          1478:                                cclcnt++;
        !          1479:                                if (ep >= &expbuf[ESIZE])
        !          1480:                                        goto cerror;
        !          1481:                        } while ((c = getchr()) != ']');
        !          1482:                        lastep[1] = cclcnt;
        !          1483:                        continue;
        !          1484: 
        !          1485:                defchar:
        !          1486:                default:
        !          1487:                        *ep++ = CCHR;
        !          1488:                        *ep++ = c;
        !          1489:                }
        !          1490:        }
        !          1491:    cerror:
        !          1492:        expbuf[0] = 0;
        !          1493:        nbra = 0;
        !          1494:        error(Q);
        !          1495: }
        !          1496: 
        !          1497: execute(int *addr)
        !          1498: {
        !          1499:        short *p1, *p2;
        !          1500:        int c;
        !          1501: 
        !          1502:        for (c=0; c<NBRA; c++) {
        !          1503:                braslist[c] = 0;
        !          1504:                braelist[c] = 0;
        !          1505:        }
        !          1506:        p2 = expbuf;
        !          1507:        if (addr == (int*)0) {
        !          1508:                if (*p2 == CCIRC)
        !          1509:                        return 0;
        !          1510:                p1 = loc2;
        !          1511:        } else {
        !          1512:                if (addr == zero)
        !          1513:                        return 0;
        !          1514:                p1 = getline(*addr);
        !          1515:        }
        !          1516:        if (*p2 == CCIRC) {
        !          1517:                loc1 = p1;
        !          1518:                return advance(p1, p2+1);
        !          1519:        }
        !          1520:        /* fast check for first character */
        !          1521:        if (*p2 == CCHR) {
        !          1522:                c = p2[1];
        !          1523:                do {
        !          1524:                        if (*p1!=c)
        !          1525:                                continue;
        !          1526:                        if (advance(p1, p2)) {
        !          1527:                                loc1 = p1;
        !          1528:                                return 1;
        !          1529:                        }
        !          1530:                } while (*p1++);
        !          1531:                return 0;
        !          1532:        }
        !          1533:        /* regular algorithm */
        !          1534:        do {
        !          1535:                if (advance(p1, p2)) {
        !          1536:                        loc1 = p1;
        !          1537:                        return 1;
        !          1538:                }
        !          1539:        } while (*p1++);
        !          1540:        return 0;
        !          1541: }
        !          1542: 
        !          1543: advance(short *lp, short *ep)
        !          1544: {
        !          1545:        short *curlp;
        !          1546:        int i;
        !          1547: 
        !          1548:        for (;;)
        !          1549:        switch (*ep++) {
        !          1550: 
        !          1551:        case CCHR:
        !          1552:                if (*ep++ == *lp++)
        !          1553:                        continue;
        !          1554:                return 0;
        !          1555: 
        !          1556:        case CDOT:
        !          1557:                if (*lp++)
        !          1558:                        continue;
        !          1559:                return 0;
        !          1560: 
        !          1561:        case CDOL:
        !          1562:                if (*lp==0)
        !          1563:                        continue;
        !          1564:                return 0;
        !          1565: 
        !          1566:        case CEFIL:
        !          1567:                loc2 = lp;
        !          1568:                return 1;
        !          1569: 
        !          1570:        case CCL:
        !          1571:                if (cclass(ep, *lp++, 1)) {
        !          1572:                        ep += *ep;
        !          1573:                        continue;
        !          1574:                }
        !          1575:                return 0;
        !          1576: 
        !          1577:        case NCCL:
        !          1578:                if (cclass(ep, *lp++, 0)) {
        !          1579:                        ep += *ep;
        !          1580:                        continue;
        !          1581:                }
        !          1582:                return 0;
        !          1583: 
        !          1584:        case CBRA:
        !          1585:                braslist[*ep++] = lp;
        !          1586:                continue;
        !          1587: 
        !          1588:        case CKET:
        !          1589:                braelist[*ep++] = lp;
        !          1590:                continue;
        !          1591: 
        !          1592:        case CBACK:
        !          1593:                if (braelist[i = *ep++]==0)
        !          1594:                        error(Q);
        !          1595:                if (backref(i, lp)) {
        !          1596:                        lp += braelist[i] - braslist[i];
        !          1597:                        continue;
        !          1598:                }
        !          1599:                return 0;
        !          1600: 
        !          1601:        case CBACK|STAR:
        !          1602:                if (braelist[i = *ep++] == 0)
        !          1603:                        error(Q);
        !          1604:                curlp = lp;
        !          1605:                while (backref(i, lp))
        !          1606:                        lp += braelist[i] - braslist[i];
        !          1607:                while (lp >= curlp) {
        !          1608:                        if (advance(lp, ep))
        !          1609:                                return 1;
        !          1610:                        lp -= braelist[i] - braslist[i];
        !          1611:                }
        !          1612:                continue;
        !          1613: 
        !          1614:        case CDOT|STAR:
        !          1615:                curlp = lp;
        !          1616:                while (*lp++)
        !          1617:                        ;
        !          1618:                goto star;
        !          1619: 
        !          1620:        case CCHR|STAR:
        !          1621:                curlp = lp;
        !          1622:                while (*lp++ == *ep)
        !          1623:                        ;
        !          1624:                ep++;
        !          1625:                goto star;
        !          1626: 
        !          1627:        case CCL|STAR:
        !          1628:        case NCCL|STAR:
        !          1629:                curlp = lp;
        !          1630:                while (cclass(ep, *lp++, ep[-1]==(CCL|STAR)))
        !          1631:                        ;
        !          1632:                ep += *ep;
        !          1633:                goto star;
        !          1634: 
        !          1635:        star:
        !          1636:                do {
        !          1637:                        lp--;
        !          1638:                        if (advance(lp, ep))
        !          1639:                                return 1;
        !          1640:                } while (lp > curlp);
        !          1641:                return 0;
        !          1642: 
        !          1643:        default:
        !          1644:                error(Q);
        !          1645:        }
        !          1646: }
        !          1647: 
        !          1648: backref(int i, short *lp)
        !          1649: {
        !          1650:        short *bp;
        !          1651: 
        !          1652:        bp = braslist[i];
        !          1653:        while (*bp++ == *lp++)
        !          1654:                if (bp >= braelist[i])
        !          1655:                        return 1;
        !          1656:        return 0;
        !          1657: }
        !          1658: 
        !          1659: cclass(short *set, int c, int af)
        !          1660: {
        !          1661:        int n;
        !          1662: 
        !          1663:        if (c==0)
        !          1664:                return 0;
        !          1665:        n = *set++;
        !          1666:        while (--n)
        !          1667:                if (*set++ == c)
        !          1668:                        return af;
        !          1669:        return !af;
        !          1670: }
        !          1671: 
        !          1672: void
        !          1673: putd(void)
        !          1674: {
        !          1675:        int r;
        !          1676: 
        !          1677:        r = count%10;
        !          1678:        count /= 10;
        !          1679:        if (count)
        !          1680:                putd();
        !          1681:        putchr(r + '0');
        !          1682: }
        !          1683: 
        !          1684: void
        !          1685: putst(char *sp)
        !          1686: {
        !          1687:        col = 0;
        !          1688:        while (*sp)
        !          1689:                putchr(*sp++);
        !          1690:        putchr('\n');
        !          1691: }
        !          1692: 
        !          1693: void
        !          1694: putshst(short *sp)
        !          1695: {
        !          1696:        col = 0;
        !          1697:        while (*sp)
        !          1698:                putchr(*sp++);
        !          1699:        putchr('\n');
        !          1700: }
        !          1701: 
        !          1702: char   line[70];
        !          1703: char   *linp   = line;
        !          1704: 
        !          1705: void
        !          1706: putchr(int ac)
        !          1707: {
        !          1708:        char *lp;
        !          1709:        int c;
        !          1710: 
        !          1711:        lp = linp;
        !          1712:        c = ac;
        !          1713:        if (listf) {
        !          1714:                if (c=='\n') {
        !          1715:                        if (linp!=line && linp[-1]==' ') {
        !          1716:                                *lp++ = '\\';
        !          1717:                                *lp++ = 'n';
        !          1718:                        }
        !          1719:                } else {
        !          1720:                        if (col > (72-4-2)) {
        !          1721:                                col = 8;
        !          1722:                                *lp++ = '\\';
        !          1723:                                *lp++ = '\n';
        !          1724:                                *lp++ = '\t';
        !          1725:                        }
        !          1726:                        col++;
        !          1727:                        if (c=='\b' || c=='\t' || c=='\\') {
        !          1728:                                *lp++ = '\\';
        !          1729:                                if (c=='\b')
        !          1730:                                        c = 'b';
        !          1731:                                else if (c=='\t')
        !          1732:                                        c = 't';
        !          1733:                                col++;
        !          1734:                        } else if (c<' ' || c>='\177') {
        !          1735:                                *lp++ = '\\';
        !          1736:                                *lp++ = 'x';
        !          1737:                                *lp++ =  hex[c>>4];
        !          1738:                                c     =  hex[c&0xF];
        !          1739:                                col += 3;
        !          1740:                        }
        !          1741:                }
        !          1742:        }
        !          1743:        *lp++ = c;
        !          1744:        if(c == '\n' || lp >= &line[64]) {
        !          1745:                linp = line;
        !          1746:                write(oflag?2:1, line, lp-line);
        !          1747:                return;
        !          1748:        }
        !          1749:        linp = lp;
        !          1750: }

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