Return to ed.i CVS log

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

Annotation of researchv8dc/cmd/ed/ed.i, revision 1.1

1.1     ! root        1: 
        !             2: 
        !             3: 
        !             4: 
        !             5: 
        !             6: 
        !             7: 
        !             8: 
        !             9: 
        !            10: 
        !            11: 
        !            12: 
        !            13: 
        !            14: 
        !            15: 
        !            16: 
        !            17: 
        !            18: 
        !            19: 
        !            20: 
        !            21: 
        !            22: 
        !            23: 
        !            24: 
        !            25: 
        !            26: 
        !            27: 
        !            28: 
        !            29: 
        !            30: 
        !            31: 
        !            32: 
        !            33: 
        !            34: 
        !            35: 
        !            36: 
        !            37: 
        !            38: 
        !            39: 
        !            40: 
        !            41: 
        !            42: 
        !            43: 
        !            44: typedef int    (*SIG_TYP)();
        !            45: SIG_TYP signal();
        !            46: 
        !            47: 
        !            48: 
        !            49: 
        !            50: 
        !            51: 
        !            52: 
        !            53: 
        !            54: 
        !            55: 
        !            56: 
        !            57: 
        !            58: 
        !            59: 
        !            60: 
        !            61: 
        !            62: 
        !            63: 
        !            64: 
        !            65: 
        !            66: 
        !            67: 
        !            68: 
        !            69: 
        !            70: 
        !            71: 
        !            72: 
        !            73: 
        !            74: 
        !            75: 
        !            76: 
        !            77: 
        !            78: 
        !            79: 
        !            80: 
        !            81: 
        !            82: 
        !            83: 
        !            84: 
        !            85: 
        !            86: typedef        unsigned char   u_char;
        !            87: typedef        unsigned short  u_short;
        !            88: typedef        unsigned int    u_int;
        !            89: typedef        unsigned long   u_long;
        !            90: 
        !            91: 
        !            92: 
        !            93: typedef        struct  _physadr { int r[1]; } *physadr;
        !            94: typedef        long    daddr_t;
        !            95: typedef        char *  caddr_t;
        !            96: typedef        u_short ino_t;
        !            97: typedef        long    swblk_t;
        !            98: typedef        long    size_t;
        !            99: typedef        long    time_t;
        !           100: typedef        long    label_t[14];
        !           101: typedef        short   dev_t;
        !           102: typedef        long    off_t;
        !           103: typedef long   portid_t;
        !           104: 
        !           105: 
        !           106: 
        !           107: 
        !           108: 
        !           109: 
        !           110: 
        !           111: 
        !           112: 
        !           113: 
        !           114: 
        !           115: 
        !           116: 
        !           117: 
        !           118: 
        !           119: 
        !           120: 
        !           121: 
        !           122: 
        !           123: 
        !           124: 
        !           125: 
        !           126: 
        !           127: 
        !           128: 
        !           129: 
        !           130: 
        !           131: 
        !           132: 
        !           133: 
        !           134: 
        !           135: 
        !           136: 
        !           137: 
        !           138: 
        !           139: 
        !           140: 
        !           141: 
        !           142: 
        !           143: 
        !           144: 
        !           145: 
        !           146: 
        !           147: 
        !           148: 
        !           149: 
        !           150: 
        !           151: 
        !           152: 
        !           153: 
        !           154: 
        !           155: 
        !           156: 
        !           157: 
        !           158: 
        !           159: 
        !           160: 
        !           161: 
        !           162: 
        !           163: 
        !           164: 
        !           165: 
        !           166: 
        !           167: 
        !           168: 
        !           169: 
        !           170: 
        !           171: 
        !           172: 
        !           173: 
        !           174: 
        !           175: 
        !           176: 
        !           177: 
        !           178: 
        !           179: 
        !           180: 
        !           181: 
        !           182: 
        !           183: 
        !           184: 
        !           185: 
        !           186: 
        !           187: 
        !           188: 
        !           189: 
        !           190: 
        !           191: 
        !           192: 
        !           193: 
        !           194: 
        !           195: 
        !           196: 
        !           197: 
        !           198: 
        !           199: 
        !           200: 
        !           201: 
        !           202: 
        !           203: 
        !           204: 
        !           205: 
        !           206: 
        !           207: 
        !           208: 
        !           209: 
        !           210: 
        !           211: 
        !           212: 
        !           213: 
        !           214: 
        !           215: 
        !           216: 
        !           217: 
        !           218: 
        !           219: 
        !           220: 
        !           221: 
        !           222: 
        !           223: 
        !           224: 
        !           225: 
        !           226: 
        !           227: 
        !           228: 
        !           229: 
        !           230: 
        !           231: 
        !           232: 
        !           233: 
        !           234: 
        !           235: 
        !           236: 
        !           237: 
        !           238: 
        !           239: 
        !           240: 
        !           241: 
        !           242: 
        !           243: 
        !           244: 
        !           245: 
        !           246: 
        !           247: 
        !           248: 
        !           249: 
        !           250: 
        !           251: 
        !           252: 
        !           253: 
        !           254: 
        !           255: 
        !           256: 
        !           257: 
        !           258: 
        !           259: 
        !           260: 
        !           261: 
        !           262: 
        !           263: 
        !           264: 
        !           265: 
        !           266: 
        !           267: 
        !           268: 
        !           269: 
        !           270: 
        !           271: 
        !           272: 
        !           273: 
        !           274: 
        !           275: 
        !           276: 
        !           277: 
        !           278: 
        !           279: 
        !           280: 
        !           281: 
        !           282: 
        !           283: 
        !           284: 
        !           285: 
        !           286: 
        !           287: 
        !           288: 
        !           289: typedef struct fd_set { unsigned long fds_bits[        (128            +       sizeof(int)     *       8               -1)/(   sizeof(int)     *       8               )]; } fd_set;
        !           290: 
        !           291: 
        !           292: 
        !           293: 
        !           294: 
        !           295: 
        !           296: 
        !           297: 
        !           298: 
        !           299: 
        !           300: 
        !           301: 
        !           302: 
        !           303: struct sgttyb {
        !           304:        char    sg_ispeed;              
        !           305:        char    sg_ospeed;              
        !           306:        char    sg_erase;               
        !           307:        char    sg_kill;                
        !           308:        short   sg_flags;               
        !           309: };
        !           310: 
        !           311: 
        !           312: 
        !           313: 
        !           314: struct tchars {
        !           315:        char    t_intrc;        
        !           316:        char    t_quitc;        
        !           317:        char    t_startc;       
        !           318:        char    t_stopc;        
        !           319:        char    t_eofc;         
        !           320:        char    t_brkc;         
        !           321: };
        !           322: 
        !           323: 
        !           324: 
        !           325: 
        !           326: struct insld {
        !           327:        short   ld;
        !           328:        short   level;
        !           329: };
        !           330: 
        !           331: 
        !           332: 
        !           333: 
        !           334: struct passfd {
        !           335:        union  {
        !           336:                struct  file *fp;
        !           337:                int     fd;
        !           338:        } f;
        !           339:        short   uid;
        !           340:        short   gid;
        !           341:        short   nice;
        !           342:        short   fill;
        !           343: };
        !           344: 
        !           345: 
        !           346: 
        !           347: 
        !           348: 
        !           349: 
        !           350: 
        !           351: 
        !           352: 
        !           353: 
        !           354: 
        !           355: 
        !           356: 
        !           357: 
        !           358: 
        !           359: 
        !           360: 
        !           361: 
        !           362: 
        !           363: 
        !           364: 
        !           365: 
        !           366: 
        !           367: 
        !           368: 
        !           369: 
        !           370: 
        !           371: 
        !           372: 
        !           373: 
        !           374: 
        !           375: 
        !           376: 
        !           377: 
        !           378: 
        !           379: 
        !           380: 
        !           381: 
        !           382: 
        !           383: 
        !           384: 
        !           385: 
        !           386: 
        !           387: 
        !           388: 
        !           389: 
        !           390: 
        !           391: 
        !           392: 
        !           393: 
        !           394: 
        !           395: 
        !           396: 
        !           397: 
        !           398: 
        !           399: 
        !           400: 
        !           401: 
        !           402: 
        !           403: 
        !           404: 
        !           405: 
        !           406: 
        !           407: 
        !           408: 
        !           409: 
        !           410: 
        !           411: 
        !           412: 
        !           413: 
        !           414: 
        !           415: 
        !           416: 
        !           417: 
        !           418: 
        !           419: 
        !           420: 
        !           421: 
        !           422: 
        !           423: 
        !           424: 
        !           425: 
        !           426: 
        !           427: 
        !           428: 
        !           429: 
        !           430: 
        !           431: 
        !           432: 
        !           433: 
        !           434: 
        !           435: 
        !           436: 
        !           437: 
        !           438: 
        !           439: 
        !           440: 
        !           441: 
        !           442: 
        !           443: 
        !           444: 
        !           445: 
        !           446: 
        !           447: 
        !           448: 
        !           449: 
        !           450: 
        !           451: 
        !           452: 
        !           453: 
        !           454: 
        !           455: 
        !           456: 
        !           457: 
        !           458: 
        !           459: 
        !           460: 
        !           461: 
        !           462: 
        !           463: 
        !           464: 
        !           465: struct ltchars {
        !           466:        char    t_suspc;        
        !           467:        char    t_dsuspc;       
        !           468:        char    t_rprntc;       
        !           469:        char    t_flushc;       
        !           470:        char    t_werasc;       
        !           471:        char    t_lnextc;       
        !           472: };
        !           473: 
        !           474: 
        !           475: 
        !           476: 
        !           477: 
        !           478: struct luchars {
        !           479:        char    t_undoc;        
        !           480:        char    t_urotc;        
        !           481: };
        !           482: 
        !           483: 
        !           484: 
        !           485: 
        !           486: 
        !           487: 
        !           488: 
        !           489: 
        !           490: 
        !           491: 
        !           492: 
        !           493: 
        !           494: 
        !           495: 
        !           496: 
        !           497: 
        !           498: 
        !           499: 
        !           500: 
        !           501: 
        !           502: 
        !           503: 
        !           504: 
        !           505: 
        !           506: 
        !           507: 
        !           508: 
        !           509: 
        !           510: 
        !           511: 
        !           512: 
        !           513: 
        !           514: 
        !           515: 
        !           516: 
        !           517: 
        !           518: 
        !           519: 
        !           520: 
        !           521: 
        !           522: 
        !           523: 
        !           524: 
        !           525: 
        !           526: 
        !           527: 
        !           528: 
        !           529: 
        !           530: 
        !           531: 
        !           532: 
        !           533: 
        !           534: 
        !           535: 
        !           536: 
        !           537: 
        !           538: 
        !           539: 
        !           540: 
        !           541: 
        !           542: 
        !           543: 
        !           544: 
        !           545: 
        !           546: 
        !           547: 
        !           548: 
        !           549: 
        !           550: 
        !           551: 
        !           552: 
        !           553: 
        !           554: 
        !           555: 
        !           556: 
        !           557: 
        !           558: 
        !           559: 
        !           560: 
        !           561: 
        !           562: 
        !           563: 
        !           564: 
        !           565: 
        !           566: 
        !           567: 
        !           568: 
        !           569: 
        !           570: 
        !           571: 
        !           572: 
        !           573: 
        !           574: 
        !           575: 
        !           576: 
        !           577: 
        !           578: 
        !           579: 
        !           580: 
        !           581: 
        !           582: 
        !           583: 
        !           584: 
        !           585: 
        !           586: 
        !           587: 
        !           588: 
        !           589: 
        !           590: 
        !           591: 
        !           592: 
        !           593: 
        !           594: 
        !           595: 
        !           596: 
        !           597: 
        !           598: 
        !           599: 
        !           600: 
        !           601: 
        !           602: 
        !           603: 
        !           604: 
        !           605: 
        !           606: 
        !           607: 
        !           608: 
        !           609: 
        !           610: 
        !           611: 
        !           612: 
        !           613: 
        !           614: 
        !           615: 
        !           616: 
        !           617: 
        !           618: 
        !           619: 
        !           620: 
        !           621: 
        !           622: 
        !           623: 
        !           624: 
        !           625: 
        !           626: 
        !           627: 
        !           628: 
        !           629: 
        !           630: typedef int jmp_buf[10];
        !           631: 
        !           632: 
        !           633: 
        !           634: 
        !           635: 
        !           636: 
        !           637: 
        !           638: 
        !           639: 
        !           640: 
        !           641: 
        !           642: 
        !           643: 
        !           644: 
        !           645: 
        !           646: 
        !           647: 
        !           648: 
        !           649: 
        !           650: 
        !           651: 
        !           652: char   Q[]     = "";
        !           653: char   T[]     = "TMP";
        !           654: 
        !           655: 
        !           656: 
        !           657: int    peekc;
        !           658: int    lastc;
        !           659: char   savedfile[128];
        !           660: char   file[128];
        !           661: char   linebuf[512];
        !           662: char   rhsbuf[512/2];
        !           663: char   expbuf[256+4];
        !           664: int    circfl;
        !           665: int    *zero;
        !           666: int    *dot;
        !           667: int    *dol;
        !           668: int    given;
        !           669: int    *addr1;
        !           670: int    *addr2;
        !           671: char   genbuf[512];
        !           672: long   count;
        !           673: char   *nextip;
        !           674: char   *linebp;
        !           675: int    ninbuf;
        !           676: int    io;
        !           677: int    pflag;
        !           678: long   lseek();
        !           679: int    (*oldhup)();
        !           680: int    (*oldquit)();
        !           681: int    vflag   = 1;
        !           682: int    xflag;
        !           683: int    xtflag;
        !           684: int    kflag;
        !           685: int    oflag;
        !           686: char   key[9 + 1];
        !           687: char   crbuf[512];
        !           688: char   perm[768];
        !           689: char   tperm[768];
        !           690: int    listf;
        !           691: int    listn;
        !           692: int    col;
        !           693: char   *globp;
        !           694: int    tfile   = -1;
        !           695: int    tline;
        !           696: char   *tfname;
        !           697: char   *loc1;
        !           698: char   *loc2;
        !           699: char   *locs;
        !           700: char   ibuff[512];
        !           701: int    iblock  = -1;
        !           702: char   obuff[512];
        !           703: int    oblock  = -1;
        !           704: int    ichanged;
        !           705: int    nleft;
        !           706: char   WRERR[] = "WRITE ERROR";
        !           707: int    names[26];
        !           708: int    anymarks;
        !           709: char   *braslist[5];
        !           710: char   *braelist[5];
        !           711: int    nbra;
        !           712: int    subnewa;
        !           713: int    subolda;
        !           714: int    fchange;
        !           715: int    wrapp;
        !           716: int    bpagesize = 20;
        !           717: unsigned nlall = 128;
        !           718: 
        !           719: int    *address();
        !           720: char   *getline();
        !           721: char   *getblock();
        !           722: char   *place();
        !           723: char   *mktemp();
        !           724: char   *malloc();
        !           725: char   *realloc();
        !           726: jmp_buf        savej;
        !           727: 
        !           728: main(argc, argv)
        !           729: char **argv;
        !           730: {
        !           731:        register char *p1, *p2;
        !           732:        extern int onintr(), quit(), onhup();
        !           733:        int (*oldintr)();
        !           734: 
        !           735:        oldquit = signal(3      ,       (int (*)())1);
        !           736:        oldhup = signal(1       ,       (int (*)())1);
        !           737:        oldintr = signal(2      ,       (int (*)())1);
        !           738:        if ((int)signal(15      ,       (int (*)())1) == 0)
        !           739:                signal(15       , quit);
        !           740:        argv++;
        !           741:        while (argc > 1 && **argv=='-') {
        !           742:                switch((*argv)[1]) {
        !           743: 
        !           744:                case '\0':
        !           745:                        vflag = 0;
        !           746:                        break;
        !           747: 
        !           748:                case 'q':
        !           749:                        signal(3        ,       (int (*)())0);
        !           750:                        vflag = 1;
        !           751:                        break;
        !           752: 
        !           753:                case 'X':
        !           754:                        xflag = 1;
        !           755:                        break;
        !           756: 
        !           757:                case 'o':
        !           758:                        oflag = 1;
        !           759:                        vflag = 0;
        !           760:                        break;
        !           761:                }
        !           762:                argv++;
        !           763:                argc--;
        !           764:        }
        !           765:        if(xflag){
        !           766:                getkey();
        !           767:                kflag = crinit(key, perm);
        !           768:        }
        !           769: 
        !           770:        if (oflag) {
        !           771:                p1 = "/dev/stdout";
        !           772:                p2 = savedfile;
        !           773:                while (*p2++ = *p1++)
        !           774:                        ;
        !           775:                globp = "a";
        !           776:        } else if (argc>1) {
        !           777:                p1 = *argv;
        !           778:                p2 = savedfile;
        !           779:                while (*p2++ = *p1++)
        !           780:                        if (p2 >= &savedfile[sizeof(savedfile)])
        !           781:                                p2--;
        !           782:                globp = "r";
        !           783:        }
        !           784:        zero = (int *)malloc(nlall*sizeof(int));
        !           785:        tfname = mktemp("/tmp/eXXXXX");
        !           786:        init();
        !           787:        if (((int)oldintr&01) == 0)
        !           788:                signal(2        , onintr);
        !           789:        if (((int)oldhup&01) == 0)
        !           790:                signal(1        , onhup);
        !           791:        setjmp(savej);
        !           792:        commands();
        !           793:        quit();
        !           794: }
        !           795: 
        !           796: commands()
        !           797: {
        !           798:        int getfile(), gettty();
        !           799:        register *a1, c;
        !           800:        register int temp;
        !           801:        char lastsep;
        !           802: 
        !           803:        for (;;) {
        !           804:        if (pflag) {
        !           805:                pflag = 0;
        !           806:                addr1 = addr2 = dot;
        !           807:                print();
        !           808:        }
        !           809:        c = '\n';
        !           810:        for (addr1 = 0;;) {
        !           811:                lastsep = c;
        !           812:                a1 = address();
        !           813:                c = getchr();
        !           814:                if (c!=',' && c!=';')
        !           815:                        break;
        !           816:                if (lastsep==',')
        !           817:                        error(Q);
        !           818:                if (a1==0) {
        !           819:                        a1 = zero+1;
        !           820:                        if (a1>dol)
        !           821:                                a1--;
        !           822:                }
        !           823:                addr1 = a1;
        !           824:                if (c==';')
        !           825:                        dot = a1;
        !           826:        }
        !           827:        if (lastsep!='\n' && a1==0)
        !           828:                a1 = dol;
        !           829:        if ((addr2=a1)==0) {
        !           830:                given = 0;
        !           831:                addr2 = dot;    
        !           832:        }
        !           833:        else
        !           834:                given = 1;
        !           835:        if (addr1==0)
        !           836:                addr1 = addr2;
        !           837:        switch(c) {
        !           838: 
        !           839:        case 'a':
        !           840:                add(0);
        !           841:                continue;
        !           842: 
        !           843:        case 'b':
        !           844:                nonzero();
        !           845:                browse();
        !           846:                continue;
        !           847: 
        !           848:        case 'c':
        !           849:                nonzero();
        !           850:                newline();
        !           851:                rdelete(addr1, addr2);
        !           852:                append(gettty, addr1-1);
        !           853:                continue;
        !           854: 
        !           855:        case 'd':
        !           856:                nonzero();
        !           857:                newline();
        !           858:                rdelete(addr1, addr2);
        !           859:                continue;
        !           860: 
        !           861:        case 'E':
        !           862:                fchange = 0;
        !           863:                c = 'e';
        !           864:        case 'e':
        !           865:                setnoaddr();
        !           866:                if (vflag && fchange) {
        !           867:                        fchange = 0;
        !           868:                        error(Q);
        !           869:                }
        !           870:                filename(c);
        !           871:                init();
        !           872:                addr2 = zero;
        !           873:                goto caseread;
        !           874: 
        !           875:        case 'f':
        !           876:                setnoaddr();
        !           877:                filename(c);
        !           878:                puts(savedfile);
        !           879:                continue;
        !           880: 
        !           881:        case 'g':
        !           882:                global(1);
        !           883:                continue;
        !           884: 
        !           885:        case 'i':
        !           886:                add(-1);
        !           887:                continue;
        !           888: 
        !           889: 
        !           890:        case 'j':
        !           891:                if (!given)
        !           892:                        addr2++;
        !           893:                newline();
        !           894:                join();
        !           895:                continue;
        !           896: 
        !           897:        case 'k':
        !           898:                nonzero();
        !           899:                if ((c = getchr()) < 'a' || c > 'z')
        !           900:                        error(Q);
        !           901:                newline();
        !           902:                names[c-'a'] = *addr2 & ~01;
        !           903:                anymarks |= 01;
        !           904:                continue;
        !           905: 
        !           906:        case 'm':
        !           907:                move(0);
        !           908:                continue;
        !           909: 
        !           910:        case 'n':
        !           911:                listn++;
        !           912:                newline();
        !           913:                print();
        !           914:                continue;
        !           915: 
        !           916:        case '\n':
        !           917:                if (a1==0) {
        !           918:                        a1 = dot+1;
        !           919:                        addr2 = a1;
        !           920:                        addr1 = a1;
        !           921:                }
        !           922:                if (lastsep==';')
        !           923:                        addr1 = a1;
        !           924:                print();
        !           925:                continue;
        !           926: 
        !           927:        case 'l':
        !           928:                listf++;
        !           929:        case 'p':
        !           930:        case 'P':
        !           931:                newline();
        !           932:                print();
        !           933:                continue;
        !           934: 
        !           935:        case 'Q':
        !           936:                fchange = 0;
        !           937:        case 'q':
        !           938:                setnoaddr();
        !           939:                newline();
        !           940:                quit();
        !           941: 
        !           942:        case 'r':
        !           943:                filename(c);
        !           944:        caseread:
        !           945:                if ((io = open(file, 0)) < 0) {
        !           946:                        lastc = '\n';
        !           947:                        error(file);
        !           948:                }
        !           949:                setwide();
        !           950:                squeeze(0);
        !           951:                ninbuf = 0;
        !           952:                c = zero != dol;
        !           953:                append(getfile, addr2);
        !           954:                exfile();
        !           955:                fchange = c;
        !           956:                continue;
        !           957: 
        !           958:        case 's':
        !           959:                nonzero();
        !           960:                substitute(globp!=0);
        !           961:                continue;
        !           962: 
        !           963:        case 't':
        !           964:                move(1);
        !           965:                continue;
        !           966: 
        !           967:        case 'u':
        !           968:                nonzero();
        !           969:                newline();
        !           970:                if ((*addr2&~01) != subnewa)
        !           971:                        error(Q);
        !           972:                *addr2 = subolda;
        !           973:                dot = addr2;
        !           974:                continue;
        !           975: 
        !           976:        case 'v':
        !           977:                global(0);
        !           978:                continue;
        !           979: 
        !           980:        case 'W':
        !           981:                wrapp++;
        !           982:        case 'w':
        !           983:                setwide();
        !           984:                squeeze(dol>zero);
        !           985:                if ((temp = getchr()) != 'q' && temp != 'Q') {
        !           986:                        peekc = temp;
        !           987:                        temp = 0;
        !           988:                }
        !           989:                filename(c);
        !           990:                if(!wrapp ||
        !           991:                  ((io = open(file,1)) == -1) ||
        !           992:                  ((lseek(io, 0L, 2)) == -1))
        !           993:                        if ((io = creat(file, 0666)) < 0)
        !           994:                                error(file);
        !           995:                wrapp = 0;
        !           996:                if (dol > zero)
        !           997:                        putfile();
        !           998:                exfile();
        !           999:                if (addr1<=zero+1 && addr2==dol)
        !          1000:                        fchange = 0;
        !          1001:                if (temp == 'Q')
        !          1002:                        fchange = 0;
        !          1003:                if (temp)
        !          1004:                        quit();
        !          1005:                continue;
        !          1006: 
        !          1007:        case 'X':
        !          1008:                setnoaddr();
        !          1009:                newline();
        !          1010:                xflag = 1;
        !          1011:                puts("Entering encrypting mode!");
        !          1012:                getkey();
        !          1013:                kflag = crinit(key, perm);
        !          1014:                continue;
        !          1015: 
        !          1016: 
        !          1017:        case '=':
        !          1018:                setwide();
        !          1019:                squeeze(0);
        !          1020:                newline();
        !          1021:                count = addr2 - zero;
        !          1022:                putd();
        !          1023:                putchr('\n');
        !          1024:                continue;
        !          1025: 
        !          1026:        case '!':
        !          1027:                callunix();
        !          1028:                continue;
        !          1029: 
        !          1030:        case -1:
        !          1031:                return;
        !          1032: 
        !          1033:        }
        !          1034:        error(Q);
        !          1035:        }
        !          1036: }
        !          1037: 
        !          1038: print(){
        !          1039:        register int *a1;
        !          1040:        nonzero();
        !          1041:        a1 = addr1;
        !          1042:        do {
        !          1043:                if (listn) {
        !          1044:                        count = a1-zero;
        !          1045:                        putd();
        !          1046:                        putchr('\t');
        !          1047:                }
        !          1048:                puts(getline(*a1++));
        !          1049:        } while (a1 <= addr2);
        !          1050:        dot = addr2;
        !          1051:        listf = 0;
        !          1052:        listn = 0;
        !          1053:        pflag = 0;
        !          1054: }
        !          1055: 
        !          1056: int *
        !          1057: address()
        !          1058: {
        !          1059:        register int sign, *a;
        !          1060:        int opcnt, nextopand, *b;
        !          1061:        register int c;
        !          1062: 
        !          1063:        nextopand = -1;
        !          1064:        sign = 1;
        !          1065:        opcnt = 0;
        !          1066:        a = dot;
        !          1067:        do {
        !          1068:                do c = getchr(); while (c==' ' || c=='\t');
        !          1069:                if ('0'<=c && c<='9') {
        !          1070:                        peekc = c;
        !          1071:                        if (!opcnt)
        !          1072:                                a = zero;
        !          1073:                        a += sign*getnum();
        !          1074:                } else switch (c) {
        !          1075:                case '$':
        !          1076:                        a = dol;
        !          1077:                        
        !          1078:                case '.':
        !          1079:                        if (opcnt)
        !          1080:                                error(Q);
        !          1081:                        break;
        !          1082:                case '\'':
        !          1083:                        c = getchr();
        !          1084:                        if (opcnt || c<'a' || 'z'<c)
        !          1085:                                error(Q);
        !          1086:                        a = zero;
        !          1087:                        do a++; while (a<=dol && names[c-'a']!=(*a&~01));
        !          1088:                        break;
        !          1089:                case '?':
        !          1090:                        sign = -sign;
        !          1091:                        
        !          1092:                case '/':
        !          1093:                        compile(c);
        !          1094:                        b = a;
        !          1095:                        for (;;) {
        !          1096:                                a += sign;
        !          1097:                                if (a<zero)
        !          1098:                                        a = dol;
        !          1099:                                if (a>dol)
        !          1100:                                        a = zero;
        !          1101:                                if (execute(a))
        !          1102:                                        break;
        !          1103:                                if (a==b)
        !          1104:                                        error(Q);
        !          1105:                        }
        !          1106:                        break;
        !          1107:                default:
        !          1108:                        if (nextopand == opcnt) {
        !          1109:                                a += sign;
        !          1110:                                if (a<zero || dol<a)
        !          1111:                                        continue;       
        !          1112:                        }
        !          1113:                        if (c!='+' && c!='-' && c!='^') {
        !          1114:                                peekc = c;
        !          1115:                                if (opcnt==0)
        !          1116:                                        a = 0;
        !          1117:                                return (a);
        !          1118:                        }
        !          1119:                        sign = 1;
        !          1120:                        if (c!='+')
        !          1121:                                sign = -sign;
        !          1122:                        nextopand = ++opcnt;
        !          1123:                        continue;
        !          1124:                }
        !          1125:                sign = 1;
        !          1126:                opcnt++;
        !          1127:        } while (zero<=a && a<=dol);
        !          1128:        error(Q);
        !          1129:        
        !          1130: }
        !          1131: int getnum()
        !          1132: {
        !          1133:        register int r, c;
        !          1134: 
        !          1135:        r = 0;
        !          1136:        while ((c=getchr())>='0' && c<='9')
        !          1137:                r = r*10 + c - '0';
        !          1138:        peekc = c;
        !          1139:        return (r);
        !          1140: }
        !          1141: 
        !          1142: setwide()
        !          1143: {
        !          1144:        if (!given) {
        !          1145:                addr1 = zero + (dol>zero);
        !          1146:                addr2 = dol;
        !          1147:        }
        !          1148: }
        !          1149: 
        !          1150: setnoaddr()
        !          1151: {
        !          1152:        if (given)
        !          1153:                error(Q);
        !          1154: }
        !          1155: 
        !          1156: nonzero()
        !          1157: {
        !          1158:        squeeze(1);
        !          1159: }
        !          1160: 
        !          1161: squeeze(i)
        !          1162: int i;
        !          1163: {
        !          1164:        if (addr1<zero+i || addr2>dol || addr1>addr2)
        !          1165:                error(Q);
        !          1166: }
        !          1167: 
        !          1168: newline()
        !          1169: {
        !          1170:        register c;
        !          1171: 
        !          1172:        if ((c = getchr()) == '\n' || c == -1)
        !          1173:                return;
        !          1174:        if (c=='p' || c=='l' || c=='n') {
        !          1175:                pflag++;
        !          1176:                if (c=='l')
        !          1177:                        listf++;
        !          1178:                else if (c=='n')
        !          1179:                        listn++;
        !          1180:                if ((c=getchr())=='\n')
        !          1181:                        return;
        !          1182:        }
        !          1183:        error(Q);
        !          1184: }
        !          1185: 
        !          1186: filename(comm)
        !          1187: {
        !          1188:        register char *p1, *p2;
        !          1189:        register c;
        !          1190: 
        !          1191:        count = 0;
        !          1192:        c = getchr();
        !          1193:        if (c=='\n' || c==-1) {
        !          1194:                p1 = savedfile;
        !          1195:                if (*p1==0 && comm!='f')
        !          1196:                        error(Q);
        !          1197:                p2 = file;
        !          1198:                while (*p2++ = *p1++)
        !          1199:                        ;
        !          1200:                return;
        !          1201:        }
        !          1202:        if (c!=' ')
        !          1203:                error(Q);
        !          1204:        while ((c = getchr()) == ' ')
        !          1205:                ;
        !          1206:        if (c=='\n')
        !          1207:                error(Q);
        !          1208:        p1 = file;
        !          1209:        do {
        !          1210:                if (p1 >= &file[sizeof(file)-1] || c==' ' || c==-1)
        !          1211:                        error(Q);
        !          1212:                *p1++ = c;
        !          1213:        } while ((c = getchr()) != '\n');
        !          1214:        *p1++ = 0;
        !          1215:        if (savedfile[0]==0 || comm=='e' || comm=='f') {
        !          1216:                p1 = savedfile;
        !          1217:                p2 = file;
        !          1218:                while (*p1++ = *p2++)
        !          1219:                        ;
        !          1220:        }
        !          1221: }
        !          1222: 
        !          1223: exfile()
        !          1224: {
        !          1225:        close(io);
        !          1226:        io = -1;
        !          1227:        if (vflag) {
        !          1228:                putd();
        !          1229:                putchr('\n');
        !          1230:        }
        !          1231: }
        !          1232: 
        !          1233: onintr()
        !          1234: {
        !          1235:        signal(2        , onintr);
        !          1236:        putchr('\n');
        !          1237:        lastc = '\n';
        !          1238:        error(Q);
        !          1239: }
        !          1240: 
        !          1241: onhup()
        !          1242: {
        !          1243:        signal(2        ,       (int (*)())1);
        !          1244:        signal(1        ,       (int (*)())1);
        !          1245:        if (dol > zero) {
        !          1246:                addr1 = zero+1;
        !          1247:                addr2 = dol;
        !          1248:                io = creat("ed.hup", 0666);
        !          1249:                if (io > 0)
        !          1250:                        putfile();
        !          1251:        }
        !          1252:        fchange = 0;
        !          1253:        quit();
        !          1254: }
        !          1255: 
        !          1256: error(s)
        !          1257: char *s;
        !          1258: {
        !          1259:        register c;
        !          1260: 
        !          1261:        wrapp = 0;
        !          1262:        listf = 0;
        !          1263:        listn = 0;
        !          1264:        putchr('?');
        !          1265:        puts(s);
        !          1266:        count = 0;
        !          1267:        lseek(0, (long)0, 2);
        !          1268:        pflag = 0;
        !          1269:        if (globp)
        !          1270:                lastc = '\n';
        !          1271:        globp = 0;
        !          1272:        peekc = lastc;
        !          1273:        if(lastc)
        !          1274:                while ((c = getchr()) != '\n' && c != -1)
        !          1275:                        ;
        !          1276:        if (io > 0) {
        !          1277:                close(io);
        !          1278:                io = -1;
        !          1279:        }
        !          1280:        longjmp(savej, 1);
        !          1281: }
        !          1282: 
        !          1283: getchr()
        !          1284: {
        !          1285:        char c;
        !          1286:        if (lastc=peekc) {
        !          1287:                peekc = 0;
        !          1288:                return(lastc);
        !          1289:        }
        !          1290:        if (globp) {
        !          1291:                if ((lastc = *globp++) != 0)
        !          1292:                        return(lastc);
        !          1293:                globp = 0;
        !          1294:                return(-1);
        !          1295:        }
        !          1296:        if (read(0, &c, 1) <= 0)
        !          1297:                return(lastc = -1);
        !          1298:        lastc = c&0177;
        !          1299:        return(lastc);
        !          1300: }
        !          1301: 
        !          1302: gettty()
        !          1303: {
        !          1304:        register int rc;
        !          1305: 
        !          1306:        if (rc = gety())
        !          1307:                return(rc);
        !          1308:        if (linebuf[0]=='.' && linebuf[1]==0)
        !          1309:                return(-1);
        !          1310:        return(0);
        !          1311: }
        !          1312: 
        !          1313: gety()
        !          1314: {
        !          1315:        register int c;
        !          1316:        register char *gf;
        !          1317:        register char *p;
        !          1318: 
        !          1319:        p = linebuf;
        !          1320:        gf = globp;
        !          1321:        while ((c = getchr()) != '\n') {
        !          1322:                if (c==-1) {
        !          1323:                        if (gf)
        !          1324:                                peekc = c;
        !          1325:                        return(c);
        !          1326:                }
        !          1327:                if ((c &= 0177) == 0)
        !          1328:                        continue;
        !          1329:                *p++ = c;
        !          1330:                if (p >= &linebuf[512-2])
        !          1331:                        error(Q);
        !          1332:        }
        !          1333: 
        !          1334:        *p++ = 0;
        !          1335:        return(0);
        !          1336: }
        !          1337: 
        !          1338: getfile()
        !          1339: {
        !          1340:        register c;
        !          1341:        register char *lp, *fp;
        !          1342: 
        !          1343:        lp = linebuf;
        !          1344:        fp = nextip;
        !          1345:        do {
        !          1346:                if (--ninbuf < 0) {
        !          1347:                        if ((ninbuf = read(io, genbuf, 512)-1) < 0)
        !          1348:                                if (lp>linebuf) {
        !          1349:                                        puts("'\\n' appended");
        !          1350:                                        *genbuf = '\n';
        !          1351:                                }
        !          1352:                                else return(-1);
        !          1353:                        fp = genbuf;
        !          1354:                        while(fp < &genbuf[ninbuf]) {
        !          1355:                                if (*fp++ & 0200) {
        !          1356:                                        if (kflag)
        !          1357:                                                crblock(perm, genbuf, ninbuf+1, count);
        !          1358:                                        break;
        !          1359:                                }
        !          1360:                        }
        !          1361:                        fp = genbuf;
        !          1362:                }
        !          1363:                c = *fp++;
        !          1364:                if (c=='\0')
        !          1365:                        continue;
        !          1366:                if (c&0200 || lp >= &linebuf[512]) {
        !          1367:                        lastc = '\n';
        !          1368:                        error(Q);
        !          1369:                }
        !          1370:                *lp++ = c;
        !          1371:                count++;
        !          1372:        } while (c != '\n');
        !          1373:        *--lp = 0;
        !          1374:        nextip = fp;
        !          1375:        return(0);
        !          1376: }
        !          1377: 
        !          1378: putfile()
        !          1379: {
        !          1380:        int *a1, n;
        !          1381:        register char *fp, *lp;
        !          1382:        register nib;
        !          1383: 
        !          1384:        nib = 512;
        !          1385:        fp = genbuf;
        !          1386:        a1 = addr1;
        !          1387:        do {
        !          1388:                lp = getline(*a1++);
        !          1389:                for (;;) {
        !          1390:                        if (--nib < 0) {
        !          1391:                                n = fp-genbuf;
        !          1392:                                if(kflag)
        !          1393:                                        crblock(perm, genbuf, n, count-n);
        !          1394:                                if(write(io, genbuf, n) != n) {
        !          1395:                                        puts(WRERR);
        !          1396:                                        error(Q);
        !          1397:                                }
        !          1398:                                nib = 511;
        !          1399:                                fp = genbuf;
        !          1400:                        }
        !          1401:                        count++;
        !          1402:                        if ((*fp++ = *lp++) == 0) {
        !          1403:                                fp[-1] = '\n';
        !          1404:                                break;
        !          1405:                        }
        !          1406:                }
        !          1407:        } while (a1 <= addr2);
        !          1408:        n = fp-genbuf;
        !          1409:        if(kflag)
        !          1410:                crblock(perm, genbuf, n, count-n);
        !          1411:        if(write(io, genbuf, n) != n) {
        !          1412:                puts(WRERR);
        !          1413:                error(Q);
        !          1414:        }
        !          1415: }
        !          1416: 
        !          1417: append(f, a)
        !          1418: int *a;
        !          1419: int (*f)();
        !          1420: {
        !          1421:        register *a1, *a2, *rdot;
        !          1422:        int nline, tl;
        !          1423: 
        !          1424:        nline = 0;
        !          1425:        dot = a;
        !          1426:        while ((*f)() == 0) {
        !          1427:                if ((dol-zero)+1 >= nlall) {
        !          1428:                        int *ozero = zero;
        !          1429:                        nlall += 512;
        !          1430:                        if ((zero = (int *)realloc((char *)zero, nlall*sizeof(int)))==0) {
        !          1431:                                error("MEM?");
        !          1432:                                onhup();
        !          1433:                        }
        !          1434:                        dot += zero - ozero;
        !          1435:                        dol += zero - ozero;
        !          1436:                }
        !          1437:                tl = putline();
        !          1438:                nline++;
        !          1439:                a1 = ++dol;
        !          1440:                a2 = a1+1;
        !          1441:                rdot = ++dot;
        !          1442:                while (a1 > rdot)
        !          1443:                        *--a2 = *--a1;
        !          1444:                *rdot = tl;
        !          1445:        }
        !          1446:        return(nline);
        !          1447: }
        !          1448: 
        !          1449: add(i)
        !          1450: int i;
        !          1451: {
        !          1452:        if (i && (given || dol>zero)) {
        !          1453:                addr1--;
        !          1454:                addr2--;
        !          1455:        }
        !          1456:        squeeze(0);
        !          1457:        newline();
        !          1458:        append(gettty, addr2);
        !          1459: }
        !          1460: 
        !          1461: browse()
        !          1462: {
        !          1463:        register forward, n;
        !          1464:        static bformat; 
        !          1465:        static bnum; 
        !          1466:        forward=1;
        !          1467:        if((peekc=getchr())!='\n'){
        !          1468:                if (peekc=='-' || peekc=='+') {
        !          1469:                        if(peekc=='-')
        !          1470:                                forward=0;
        !          1471:                        getchr();
        !          1472:                }
        !          1473:                if((n=getnum())>0)
        !          1474:                        bpagesize=n;
        !          1475:        }
        !          1476:        newline();
        !          1477:        if (pflag) {
        !          1478:                bformat=listf;
        !          1479:                bnum=listn;
        !          1480:        } else {
        !          1481:                listf=bformat;
        !          1482:                listn=bnum;
        !          1483:        }
        !          1484:        if (forward) {
        !          1485:                addr1=addr2;
        !          1486:                if((addr2+=bpagesize)>dol)
        !          1487:                        addr2=dol;
        !          1488:        } else {
        !          1489:                if((addr1=addr2-bpagesize)<=zero)
        !          1490:                        addr1=zero+1;
        !          1491:        }
        !          1492:        print();
        !          1493: }
        !          1494: 
        !          1495: callunix()
        !          1496: {
        !          1497:        register (*savint)(), pid, rpid;
        !          1498:        int retcode;
        !          1499: 
        !          1500:        setnoaddr();
        !          1501:        if ((pid = fork()) == 0) {
        !          1502:                signal(1        , oldhup);
        !          1503:                signal(3        , oldquit);
        !          1504:                execl("/bin/sh", "sh", "-t", 0);
        !          1505:                exit(0100);
        !          1506:        }
        !          1507:        savint = signal(2       ,       (int (*)())1);
        !          1508:        while ((rpid = wait(&retcode)) != pid && rpid != -1)
        !          1509:                ;
        !          1510:        signal(2        , savint);
        !          1511:        if (vflag) {
        !          1512:                puts("!");
        !          1513:        }
        !          1514: }
        !          1515: 
        !          1516: quit()
        !          1517: {
        !          1518:        if (vflag && fchange && dol!=zero) {
        !          1519:                fchange = 0;
        !          1520:                error(Q);
        !          1521:        }
        !          1522:        unlink(tfname);
        !          1523:        exit(0);
        !          1524: }
        !          1525: 
        !          1526: rdelete(ad1, ad2)
        !          1527: int *ad1, *ad2;
        !          1528: {
        !          1529:        register *a1, *a2, *a3;
        !          1530: 
        !          1531:        a1 = ad1;
        !          1532:        a2 = ad2+1;
        !          1533:        a3 = dol;
        !          1534:        dol -= a2 - a1;
        !          1535:        do {
        !          1536:                *a1++ = *a2++;
        !          1537:        } while (a2 <= a3);
        !          1538:        a1 = ad1;
        !          1539:        if (a1 > dol)
        !          1540:                a1 = dol;
        !          1541:        dot = a1;
        !          1542:        fchange = 1;
        !          1543: }
        !          1544: 
        !          1545: gdelete()
        !          1546: {
        !          1547:        register *a1, *a2, *a3;
        !          1548: 
        !          1549:        a3 = dol;
        !          1550:        for (a1=zero; (*a1&01)==0; a1++)
        !          1551:                if (a1>=a3)
        !          1552:                        return;
        !          1553:        for (a2=a1+1; a2<=a3;) {
        !          1554:                if (*a2&01) {
        !          1555:                        a2++;
        !          1556:                        dot = a1;
        !          1557:                } else
        !          1558:                        *a1++ = *a2++;
        !          1559:        }
        !          1560:        dol = a1-1;
        !          1561:        if (dot>dol)
        !          1562:                dot = dol;
        !          1563:        fchange = 1;
        !          1564: }
        !          1565: 
        !          1566: char *
        !          1567: getline(tl)
        !          1568: {
        !          1569:        register char *bp, *lp;
        !          1570:        register nl;
        !          1571: 
        !          1572:        lp = linebuf;
        !          1573:        bp = getblock(tl, 0);
        !          1574:        nl = nleft;
        !          1575:        tl &= ~0377;
        !          1576:        while (*lp++ = *bp++)
        !          1577:                if (--nl == 0) {
        !          1578:                        bp = getblock(tl+=0400, 0);
        !          1579:                        nl = nleft;
        !          1580:                }
        !          1581:        return(linebuf);
        !          1582: }
        !          1583: 
        !          1584: putline()
        !          1585: {
        !          1586:        register char *bp, *lp;
        !          1587:        register nl;
        !          1588:        int tl;
        !          1589: 
        !          1590:        fchange = 1;
        !          1591:        lp = linebuf;
        !          1592:        tl = tline;
        !          1593:        bp = getblock(tl, 1);
        !          1594:        nl = nleft;
        !          1595:        tl &= ~0377;
        !          1596:        while (*bp = *lp++) {
        !          1597:                if (*bp++ == '\n') {
        !          1598:                        *--bp = 0;
        !          1599:                        linebp = lp;
        !          1600:                        break;
        !          1601:                }
        !          1602:                if (--nl == 0) {
        !          1603:                        bp = getblock(tl+=0400, 1);
        !          1604:                        nl = nleft;
        !          1605:                }
        !          1606:        }
        !          1607:        nl = tline;
        !          1608:        tline += (((lp-linebuf)+03)>>1)&077776;
        !          1609:        return(nl);
        !          1610: }
        !          1611: 
        !          1612: char *
        !          1613: getblock(atl, iof)
        !          1614: {
        !          1615:        extern read(), write();
        !          1616:        register bno, off;
        !          1617:        register char *p1, *p2;
        !          1618:        register int n;
        !          1619:        
        !          1620:        bno = (atl>>8)&0377;
        !          1621:        off = (atl<<1)&0774;
        !          1622:        if (bno >= 255) {
        !          1623:                lastc = '\n';
        !          1624:                error(T);
        !          1625:        }
        !          1626:        nleft = 512 - off;
        !          1627:        if (bno==iblock) {
        !          1628:                ichanged |= iof;
        !          1629:                return(ibuff+off);
        !          1630:        }
        !          1631:        if (bno==oblock)
        !          1632:                return(obuff+off);
        !          1633:        if (iof==0) {
        !          1634:                if (ichanged) {
        !          1635:                        if(xtflag)
        !          1636:                                crblock(tperm, ibuff, 512, (long)0);
        !          1637:                        blkio(iblock, ibuff, write);
        !          1638:                }
        !          1639:                ichanged = 0;
        !          1640:                iblock = bno;
        !          1641:                blkio(bno, ibuff, read);
        !          1642:                if(xtflag)
        !          1643:                        crblock(tperm, ibuff, 512, (long)0);
        !          1644:                return(ibuff+off);
        !          1645:        }
        !          1646:        if (oblock>=0) {
        !          1647:                if(xtflag) {
        !          1648:                        p1 = obuff;
        !          1649:                        p2 = crbuf;
        !          1650:                        n = 512;
        !          1651:                        while(n--)
        !          1652:                                *p2++ = *p1++;
        !          1653:                        crblock(tperm, crbuf, 512, (long)0);
        !          1654:                        blkio(oblock, crbuf, write);
        !          1655:                } else
        !          1656:                        blkio(oblock, obuff, write);
        !          1657:        }
        !          1658:        oblock = bno;
        !          1659:        return(obuff+off);
        !          1660: }
        !          1661: 
        !          1662: blkio(b, buf, iofcn)
        !          1663: char *buf;
        !          1664: int (*iofcn)();
        !          1665: {
        !          1666:        lseek(tfile, (long)b<<9, 0);
        !          1667:        if ((*iofcn)(tfile, buf, 512) != 512) {
        !          1668:                error(T);
        !          1669:        }
        !          1670: }
        !          1671: 
        !          1672: init()
        !          1673: {
        !          1674:        register *markp;
        !          1675: 
        !          1676:        close(tfile);
        !          1677:        tline = 2;
        !          1678:        for (markp = names; markp < &names[26]; )
        !          1679:                *markp++ = 0;
        !          1680:        subnewa = 0;
        !          1681:        anymarks = 0;
        !          1682:        iblock = -1;
        !          1683:        oblock = -1;
        !          1684:        ichanged = 0;
        !          1685:        close(creat(tfname, 0600));
        !          1686:        tfile = open(tfname, 2);
        !          1687:        if(xflag) {
        !          1688:                xtflag = 1;
        !          1689:                makekey(key, tperm);
        !          1690:        }
        !          1691:        dot = dol = zero;
        !          1692: }
        !          1693: 
        !          1694: global(k)
        !          1695: {
        !          1696:        register char *gp;
        !          1697:        register c;
        !          1698:        register int *a1;
        !          1699:        char globuf[256];
        !          1700: 
        !          1701:        if (globp)
        !          1702:                error(Q);
        !          1703:        setwide();
        !          1704:        squeeze(dol>zero);
        !          1705:        if ((c=getchr())=='\n')
        !          1706:                error(Q);
        !          1707:        compile(c);
        !          1708:        gp = globuf;
        !          1709:        while ((c = getchr()) != '\n') {
        !          1710:                if (c==-1)
        !          1711:                        error(Q);
        !          1712:                if (c=='\\') {
        !          1713:                        c = getchr();
        !          1714:                        if (c!='\n')
        !          1715:                                *gp++ = '\\';
        !          1716:                }
        !          1717:                *gp++ = c;
        !          1718:                if (gp >= &globuf[256-2])
        !          1719:                        error(Q);
        !          1720:        }
        !          1721:        if (gp == globuf)
        !          1722:                *gp++ = 'p';
        !          1723:        *gp++ = '\n';
        !          1724:        *gp++ = 0;
        !          1725:        for (a1=zero; a1<=dol; a1++) {
        !          1726:                *a1 &= ~01;
        !          1727:                if (a1>=addr1 && a1<=addr2 && execute(a1)==k)
        !          1728:                        *a1 |= 01;
        !          1729:        }
        !          1730:        
        !          1731: 
        !          1732: 
        !          1733:        if (globuf[0]=='d' && globuf[1]=='\n' && globuf[2]=='\0') {
        !          1734:                gdelete();
        !          1735:                return;
        !          1736:        }
        !          1737:        for (a1=zero; a1<=dol; a1++) {
        !          1738:                if (*a1 & 01) {
        !          1739:                        *a1 &= ~01;
        !          1740:                        dot = a1;
        !          1741:                        globp = globuf;
        !          1742:                        commands();
        !          1743:                        a1 = zero;
        !          1744:                }
        !          1745:        }
        !          1746: }
        !          1747: 
        !          1748: join()
        !          1749: {
        !          1750:        register char *gp, *lp;
        !          1751:        register *a1;
        !          1752: 
        !          1753:        nonzero();
        !          1754:        gp = genbuf;
        !          1755:        for (a1=addr1; a1<=addr2; a1++) {
        !          1756:                lp = getline(*a1);
        !          1757:                while (*gp = *lp++)
        !          1758:                        if (gp++ >= &genbuf[512-2])
        !          1759:                                error(Q);
        !          1760:        }
        !          1761:        lp = linebuf;
        !          1762:        gp = genbuf;
        !          1763:        while (*lp++ = *gp++)
        !          1764:                ;
        !          1765:        *addr1 = putline();
        !          1766:        if (addr1<addr2)
        !          1767:                rdelete(addr1+1, addr2);
        !          1768:        dot = addr1;
        !          1769: }
        !          1770: 
        !          1771: substitute(inglob)
        !          1772: {
        !          1773:        register *markp, *a1, nl;
        !          1774:        int gsubf;
        !          1775:        int getsub();
        !          1776:        int n, m;
        !          1777: 
        !          1778:        n = getnum();   
        !          1779:        gsubf = compsub();
        !          1780:        for (a1 = addr1; a1 <= addr2; a1++) {
        !          1781:                if (execute(a1)){
        !          1782:                        int *ozero;
        !          1783:                        m = n;
        !          1784:                        do {
        !          1785:                                if (--m <= 0) {
        !          1786:                                        dosub();
        !          1787:                                        if (!gsubf)
        !          1788:                                                break;
        !          1789:                                }
        !          1790:                        } while (execute((int *)0));
        !          1791:                        if (m <= 0) {
        !          1792:                                inglob |= 01;
        !          1793:                                subnewa = putline();
        !          1794:                                *a1 &= ~01;
        !          1795:                                if (anymarks) {
        !          1796:                                        for (markp = names; markp < &names[26]; markp++)
        !          1797:                                                if (*markp == *a1)
        !          1798:                                                        *markp = subnewa;
        !          1799:                                }
        !          1800:                                subolda = *a1;
        !          1801:                                *a1 = subnewa;
        !          1802:                                ozero = zero;
        !          1803:                                nl = append(getsub, a1);
        !          1804:                                nl += zero-ozero;
        !          1805:                                a1 += nl;
        !          1806:                                addr2 += nl;
        !          1807:                        }
        !          1808:                }
        !          1809:        }
        !          1810:        if (inglob==0)
        !          1811:                error(Q);
        !          1812: }
        !          1813: 
        !          1814: compsub()
        !          1815: {
        !          1816:        register seof, c;
        !          1817:        register char *p;
        !          1818: 
        !          1819:        if ((seof = getchr()) == '\n' || seof == ' ')
        !          1820:                error(Q);
        !          1821:        compile(seof);
        !          1822:        p = rhsbuf;
        !          1823:        for (;;) {
        !          1824:                c = getchr();
        !          1825:                if (c=='\\')
        !          1826:                        c = getchr() | 0200;
        !          1827:                if (c=='\n') {
        !          1828:                        if (globp && globp[0])  
        !          1829:                                c |= 0200;
        !          1830:                        else {
        !          1831:                                peekc = c;
        !          1832:                                pflag++;
        !          1833:                                break;
        !          1834:                        }
        !          1835:                }
        !          1836:                if (c==seof)
        !          1837:                        break;
        !          1838:                *p++ = c;
        !          1839:                if (p >= &rhsbuf[512/2])
        !          1840:                        error(Q);
        !          1841:        }
        !          1842:        *p++ = 0;
        !          1843:        if ((peekc = getchr()) == 'g') {
        !          1844:                peekc = 0;
        !          1845:                newline();
        !          1846:                return(1);
        !          1847:        }
        !          1848:        newline();
        !          1849:        return(0);
        !          1850: }
        !          1851: 
        !          1852: getsub()
        !          1853: {
        !          1854:        register char *p1, *p2;
        !          1855: 
        !          1856:        p1 = linebuf;
        !          1857:        if ((p2 = linebp) == 0)
        !          1858:                return(-1);
        !          1859:        while (*p1++ = *p2++)
        !          1860:                ;
        !          1861:        linebp = 0;
        !          1862:        return(0);
        !          1863: }
        !          1864: 
        !          1865: dosub()
        !          1866: {
        !          1867:        register char *lp, *sp, *rp;
        !          1868:        int c;
        !          1869: 
        !          1870:        lp = linebuf;
        !          1871:        sp = genbuf;
        !          1872:        rp = rhsbuf;
        !          1873:        while (lp < loc1)
        !          1874:                *sp++ = *lp++;
        !          1875:        while (c = *rp++&0377) {
        !          1876:                if (c=='&') {
        !          1877:                        sp = place(sp, loc1, loc2);
        !          1878:                        continue;
        !          1879:                } else if (c&0200 && (c &= 0177) >='1' && c < nbra+'1') {
        !          1880:                        sp = place(sp, braslist[c-'1'], braelist[c-'1']);
        !          1881:                        continue;
        !          1882:                }
        !          1883:                *sp++ = c&0177;
        !          1884:                if (sp >= &genbuf[512])
        !          1885:                        error(Q);
        !          1886:        }
        !          1887:        lp = loc2;
        !          1888:        loc2 = sp - genbuf + linebuf;
        !          1889:        while (*sp++ = *lp++)
        !          1890:                if (sp >= &genbuf[512])
        !          1891:                        error(Q);
        !          1892:        lp = linebuf;
        !          1893:        sp = genbuf;
        !          1894:        while (*lp++ = *sp++)
        !          1895:                ;
        !          1896: }
        !          1897: 
        !          1898: char *
        !          1899: place(sp, l1, l2)
        !          1900: register char *sp, *l1, *l2;
        !          1901: {
        !          1902: 
        !          1903:        while (l1 < l2) {
        !          1904:                *sp++ = *l1++;
        !          1905:                if (sp >= &genbuf[512])
        !          1906:                        error(Q);
        !          1907:        }
        !          1908:        return(sp);
        !          1909: }
        !          1910: 
        !          1911: move(cflag)
        !          1912: {
        !          1913:        register int *adt, *ad1, *ad2;
        !          1914:        int getcopy();
        !          1915: 
        !          1916:        nonzero();
        !          1917:        if ((adt = address())==0)       
        !          1918:                error(Q);
        !          1919:        newline();
        !          1920:        if (cflag) {
        !          1921:                int *ozero, delta;
        !          1922:                ad1 = dol;
        !          1923:                ozero = zero;
        !          1924:                append(getcopy, ad1++);
        !          1925:                ad2 = dol;
        !          1926:                delta = zero - ozero;
        !          1927:                ad1 += delta;
        !          1928:                adt += delta;
        !          1929:        } else {
        !          1930:                ad2 = addr2;
        !          1931:                for (ad1 = addr1; ad1 <= ad2;)
        !          1932:                        *ad1++ &= ~01;
        !          1933:                ad1 = addr1;
        !          1934:        }
        !          1935:        ad2++;
        !          1936:        if (adt<ad1) {
        !          1937:                dot = adt + (ad2-ad1);
        !          1938:                if ((++adt)==ad1)
        !          1939:                        return;
        !          1940:                reverse(adt, ad1);
        !          1941:                reverse(ad1, ad2);
        !          1942:                reverse(adt, ad2);
        !          1943:        } else if (adt >= ad2) {
        !          1944:                dot = adt++;
        !          1945:                reverse(ad1, ad2);
        !          1946:                reverse(ad2, adt);
        !          1947:                reverse(ad1, adt);
        !          1948:        } else
        !          1949:                error(Q);
        !          1950:        fchange = 1;
        !          1951: }
        !          1952: 
        !          1953: reverse(a1, a2)
        !          1954: register int *a1, *a2;
        !          1955: {
        !          1956:        register int t;
        !          1957: 
        !          1958:        for (;;) {
        !          1959:                t = *--a2;
        !          1960:                if (a2 <= a1)
        !          1961:                        return;
        !          1962:                *a2 = *a1;
        !          1963:                *a1++ = t;
        !          1964:        }
        !          1965: }
        !          1966: 
        !          1967: getcopy()
        !          1968: {
        !          1969:        if (addr1 > addr2)
        !          1970:                return(-1);
        !          1971:        getline(*addr1++);
        !          1972:        return(0);
        !          1973: }
        !          1974: 
        !          1975: compile(aeof)
        !          1976: {
        !          1977:        register eof, c;
        !          1978:        register char *ep;
        !          1979:        char *lastep;
        !          1980:        char bracket[5], *bracketp;
        !          1981:        int cclcnt;
        !          1982: 
        !          1983:        ep = expbuf;
        !          1984:        eof = aeof;
        !          1985:        bracketp = bracket;
        !          1986:        if ((c = getchr()) == '\n') {
        !          1987:                peekc = c;
        !          1988:                c = eof;
        !          1989:        }
        !          1990:        if (c == eof) {
        !          1991:                if (*ep==0)
        !          1992:                        error(Q);
        !          1993:                return;
        !          1994:        }
        !          1995:        circfl = 0;
        !          1996:        nbra = 0;
        !          1997:        if (c=='^') {
        !          1998:                c = getchr();
        !          1999:                circfl++;
        !          2000:        }
        !          2001:        peekc = c;
        !          2002:        lastep = 0;
        !          2003:        for (;;) {
        !          2004:                if (ep >= &expbuf[256])
        !          2005:                        goto cerror;
        !          2006:                c = getchr();
        !          2007:                if (c == '\n') {
        !          2008:                        peekc = c;
        !          2009:                        c = eof;
        !          2010:                }
        !          2011:                if (c==eof) {
        !          2012:                        if (bracketp != bracket)
        !          2013:                                goto cerror;
        !          2014:                        *ep++ = 11;
        !          2015:                        return;
        !          2016:                }
        !          2017:                if (c!='*')
        !          2018:                        lastep = ep;
        !          2019:                switch (c) {
        !          2020: 
        !          2021:                case '\\':
        !          2022:                        if ((c = getchr())=='(') {
        !          2023:                                if (nbra >= 5)
        !          2024:                                        goto cerror;
        !          2025:                                *bracketp++ = nbra;
        !          2026:                                *ep++ = 1;
        !          2027:                                *ep++ = nbra++;
        !          2028:                                continue;
        !          2029:                        }
        !          2030:                        if (c == ')') {
        !          2031:                                if (bracketp <= bracket)
        !          2032:                                        goto cerror;
        !          2033:                                *ep++ = 12;
        !          2034:                                *ep++ = *--bracketp;
        !          2035:                                continue;
        !          2036:                        }
        !          2037:                        if (c>='1' && c<'1'+5) {
        !          2038:                                *ep++ = 14;
        !          2039:                                *ep++ = c-'1';
        !          2040:                                continue;
        !          2041:                        }
        !          2042:                        *ep++ = 2;
        !          2043:                        if (c=='\n')
        !          2044:                                goto cerror;
        !          2045:                        *ep++ = c;
        !          2046:                        continue;
        !          2047: 
        !          2048:                case '.':
        !          2049:                        *ep++ = 4;
        !          2050:                        continue;
        !          2051: 
        !          2052:                case '\n':
        !          2053:                        goto cerror;
        !          2054: 
        !          2055:                case '*':
        !          2056:                        if (lastep==0 || *lastep==1 || *lastep==12)
        !          2057:                                goto defchar;
        !          2058:                        *lastep |= 01;
        !          2059:                        continue;
        !          2060: 
        !          2061:                case '$':
        !          2062:                        if ((peekc=getchr()) != eof && peekc!='\n')
        !          2063:                                goto defchar;
        !          2064:                        *ep++ = 10;
        !          2065:                        continue;
        !          2066: 
        !          2067:                case '[':
        !          2068:                        *ep++ = 6;
        !          2069:                        *ep++ = 0;
        !          2070:                        cclcnt = 1;
        !          2071:                        if ((c=getchr()) == '^') {
        !          2072:                                c = getchr();
        !          2073:                                ep[-2] = 8;
        !          2074:                        }
        !          2075:                        do {
        !          2076:                                if (c=='\n')
        !          2077:                                        goto cerror;
        !          2078:                                if (c=='-' && ep[-1]!=0) {
        !          2079:                                        if ((c=getchr())==']') {
        !          2080:                                                *ep++ = '-';
        !          2081:                                                cclcnt++;
        !          2082:                                                break;
        !          2083:                                        }
        !          2084:                                        while (ep[-1]<c) {
        !          2085:                                                *ep = ep[-1]+1;
        !          2086:                                                ep++;
        !          2087:                                                cclcnt++;
        !          2088:                                                if (ep>=&expbuf[256])
        !          2089:                                                        goto cerror;
        !          2090:                                        }
        !          2091:                                }
        !          2092:                                *ep++ = c;
        !          2093:                                cclcnt++;
        !          2094:                                if (ep >= &expbuf[256])
        !          2095:                                        goto cerror;
        !          2096:                        } while ((c = getchr()) != ']');
        !          2097:                        lastep[1] = cclcnt;
        !          2098:                        continue;
        !          2099: 
        !          2100:                defchar:
        !          2101:                default:
        !          2102:                        *ep++ = 2;
        !          2103:                        *ep++ = c;
        !          2104:                }
        !          2105:        }
        !          2106:    cerror:
        !          2107:        expbuf[0] = 0;
        !          2108:        nbra = 0;
        !          2109:        error(Q);
        !          2110: }
        !          2111: 
        !          2112: execute(addr)
        !          2113: int *addr;
        !          2114: {
        !          2115:        register char *p1, *p2;
        !          2116:        register c;
        !          2117: 
        !          2118:        for (c=0; c<5; c++) {
        !          2119:                braslist[c] = 0;
        !          2120:                braelist[c] = 0;
        !          2121:        }
        !          2122:        if (addr == (int *)0) {
        !          2123:                if (circfl)
        !          2124:                        return(0);
        !          2125:                locs = p1 = loc2;
        !          2126:        } else {
        !          2127:                if (addr==zero)
        !          2128:                        return(0);
        !          2129:                p1 = getline(*addr);
        !          2130:                locs = 0;
        !          2131:        }
        !          2132:        p2 = expbuf;
        !          2133:        if (circfl) {
        !          2134:                loc1 = p1;
        !          2135:                return(advance(p1, p2));
        !          2136:        }
        !          2137:        
        !          2138:        if (*p2==2) {
        !          2139:                c = p2[1];
        !          2140:                do {
        !          2141:                        if (*p1!=c)
        !          2142:                                continue;
        !          2143:                        if (advance(p1, p2)) {
        !          2144:                                loc1 = p1;
        !          2145:                                return(1);
        !          2146:                        }
        !          2147:                } while (*p1++);
        !          2148:                return(0);
        !          2149:        }
        !          2150:        
        !          2151:        do {
        !          2152:                if (advance(p1, p2)) {
        !          2153:                        loc1 = p1;
        !          2154:                        return(1);
        !          2155:                }
        !          2156:        } while (*p1++);
        !          2157:        return(0);
        !          2158: }
        !          2159: 
        !          2160: advance(lp, ep)
        !          2161: register char *ep, *lp;
        !          2162: {
        !          2163:        register char *curlp;
        !          2164:        int i;
        !          2165: 
        !          2166:        for (;;) switch (*ep++) {
        !          2167: 
        !          2168:        case 2:
        !          2169:                if (*ep++ == *lp++)
        !          2170:                        continue;
        !          2171:                return(0);
        !          2172: 
        !          2173:        case 4:
        !          2174:                if (*lp++)
        !          2175:                        continue;
        !          2176:                return(0);
        !          2177: 
        !          2178:        case 10:
        !          2179:                if (*lp==0)
        !          2180:                        continue;
        !          2181:                return(0);
        !          2182: 
        !          2183:        case 11:
        !          2184:                loc2 = lp;
        !          2185:                return(1);
        !          2186: 
        !          2187:        case 6:
        !          2188:                if (cclass(ep, *lp++, 1)) {
        !          2189:                        ep += *ep;
        !          2190:                        continue;
        !          2191:                }
        !          2192:                return(0);
        !          2193: 
        !          2194:        case 8:
        !          2195:                if (cclass(ep, *lp++, 0)) {
        !          2196:                        ep += *ep;
        !          2197:                        continue;
        !          2198:                }
        !          2199:                return(0);
        !          2200: 
        !          2201:        case 1:
        !          2202:                braslist[*ep++] = lp;
        !          2203:                continue;
        !          2204: 
        !          2205:        case 12:
        !          2206:                braelist[*ep++] = lp;
        !          2207:                continue;
        !          2208: 
        !          2209:        case 14:
        !          2210:                if (braelist[i = *ep++]==0)
        !          2211:                        error(Q);
        !          2212:                if (backref(i, lp)) {
        !          2213:                        lp += braelist[i] - braslist[i];
        !          2214:                        continue;
        !          2215:                }
        !          2216:                return(0);
        !          2217: 
        !          2218:        case 14|01:
        !          2219:                if (braelist[i = *ep++] == 0)
        !          2220:                        error(Q);
        !          2221:                curlp = lp;
        !          2222:                while (backref(i, lp))
        !          2223:                        lp += braelist[i] - braslist[i];
        !          2224:                while (lp >= curlp) {
        !          2225:                        if (advance(lp, ep))
        !          2226:                                return(1);
        !          2227:                        lp -= braelist[i] - braslist[i];
        !          2228:                }
        !          2229:                continue;
        !          2230: 
        !          2231:        case 4|01:
        !          2232:                curlp = lp;
        !          2233:                while (*lp++)
        !          2234:                        ;
        !          2235:                goto star;
        !          2236: 
        !          2237:        case 2|01:
        !          2238:                curlp = lp;
        !          2239:                while (*lp++ == *ep)
        !          2240:                        ;
        !          2241:                ep++;
        !          2242:                goto star;
        !          2243: 
        !          2244:        case 6|01:
        !          2245:        case 8|01:
        !          2246:                curlp = lp;
        !          2247:                while (cclass(ep, *lp++, ep[-1]==(6|01)))
        !          2248:                        ;
        !          2249:                ep += *ep;
        !          2250:                goto star;
        !          2251: 
        !          2252:        star:
        !          2253:                do {
        !          2254:                        lp--;
        !          2255:                        if (lp==locs)
        !          2256:                                break;
        !          2257:                        if (advance(lp, ep))
        !          2258:                                return(1);
        !          2259:                } while (lp > curlp);
        !          2260:                return(0);
        !          2261: 
        !          2262:        default:
        !          2263:                error(Q);
        !          2264:        }
        !          2265: }
        !          2266: 
        !          2267: backref(i, lp)
        !          2268: register i;
        !          2269: register char *lp;
        !          2270: {
        !          2271:        register char *bp;
        !          2272: 
        !          2273:        bp = braslist[i];
        !          2274:        while (*bp++ == *lp++)
        !          2275:                if (bp >= braelist[i])
        !          2276:                        return(1);
        !          2277:        return(0);
        !          2278: }
        !          2279: 
        !          2280: cclass(set, c, af)
        !          2281: register char *set;
        !          2282: register c;
        !          2283: {
        !          2284:        register n;
        !          2285: 
        !          2286:        if (c==0)
        !          2287:                return(0);
        !          2288:        n = *set++;
        !          2289:        while (--n)
        !          2290:                if (*set++ == c)
        !          2291:                        return(af);
        !          2292:        return(!af);
        !          2293: }
        !          2294: 
        !          2295: putd()
        !          2296: {
        !          2297:        register r;
        !          2298: 
        !          2299:        r = count%10;
        !          2300:        count /= 10;
        !          2301:        if (count)
        !          2302:                putd();
        !          2303:        putchr(r + '0');
        !          2304: }
        !          2305: 
        !          2306: puts(sp)
        !          2307: register char *sp;
        !          2308: {
        !          2309:        col = 0;
        !          2310:        while (*sp)
        !          2311:                putchr(*sp++);
        !          2312:        putchr('\n');
        !          2313: }
        !          2314: 
        !          2315: char   line[70];
        !          2316: char   *linp   = line;
        !          2317: 
        !          2318: putchr(ac)
        !          2319: {
        !          2320:        register char *lp;
        !          2321:        register c;
        !          2322: 
        !          2323:        lp = linp;
        !          2324:        c = ac;
        !          2325:        if (listf) {
        !          2326:                if (c=='\n') {
        !          2327:                        if (linp!=line && linp[-1]==' ') {
        !          2328:                                *lp++ = '\\';
        !          2329:                                *lp++ = 'n';
        !          2330:                        }
        !          2331:                } else {
        !          2332:                        if (col > (72-4-2)) {
        !          2333:                                col = 8;
        !          2334:                                *lp++ = '\\';
        !          2335:                                *lp++ = '\n';
        !          2336:                                *lp++ = '\t';
        !          2337:                        }
        !          2338:                        col++;
        !          2339:                        if (c=='\b' || c=='\t' || c=='\\') {
        !          2340:                                *lp++ = '\\';
        !          2341:                                if (c=='\b')
        !          2342:                                        c = 'b';
        !          2343:                                else if (c=='\t')
        !          2344:                                        c = 't';
        !          2345:                                col++;
        !          2346:                        } else if (c<' ' || c=='\177') {
        !          2347:                                *lp++ = '\\';
        !          2348:                                *lp++ =  (c>>6)    +'0';
        !          2349:                                *lp++ = ((c>>3)&07)+'0';
        !          2350:                                c     = ( c    &07)+'0';
        !          2351:                                col += 3;
        !          2352:                        }
        !          2353:                }
        !          2354:        }
        !          2355:        *lp++ = c;
        !          2356:        if(c == '\n' || lp >= &line[64]) {
        !          2357:                linp = line;
        !          2358:                write(oflag?2:1, line, lp-line);
        !          2359:                return;
        !          2360:        }
        !          2361:        linp = lp;
        !          2362: }
        !          2363: crblock(permp, buf, nchar, startn)
        !          2364: char *permp;
        !          2365: char *buf;
        !          2366: long startn;
        !          2367: {
        !          2368:        register char *p1;
        !          2369:        int n1;
        !          2370:        int n2;
        !          2371:        register char *t1, *t2, *t3;
        !          2372: 
        !          2373:        t1 = permp;
        !          2374:        t2 = &permp[256];
        !          2375:        t3 = &permp[512];
        !          2376: 
        !          2377:        n1 = startn&0377;
        !          2378:        n2 = (startn>>8)&0377;
        !          2379:        p1 = buf;
        !          2380:        while(nchar--) {
        !          2381:                *p1 = t2[(t3[(t1[(*p1+n1)&0377]+n2)&0377]-n2)&0377]-n1;
        !          2382:                n1++;
        !          2383:                if(n1==256){
        !          2384:                        n1 = 0;
        !          2385:                        n2++;
        !          2386:                        if(n2==256) n2 = 0;
        !          2387:                }
        !          2388:                p1++;
        !          2389:        }
        !          2390: }
        !          2391: 
        !          2392: getkey()
        !          2393: {
        !          2394:        struct sgttyb b;
        !          2395:        int save;
        !          2396:        int (*sig)();
        !          2397:        register char *p;
        !          2398:        register c;
        !          2399: 
        !          2400:        sig = signal(2  ,       (int (*)())1);
        !          2401:        if (gtty(0, &b) == -1)
        !          2402:                error("Input not tty");
        !          2403:        save = b.sg_flags;
        !          2404:        b.sg_flags &= ~010;
        !          2405:        stty(0, &b);
        !          2406:        puts("Key:");
        !          2407:        p = key;
        !          2408:        while(((c=getchr()) != -1) && (c!='\n')) {
        !          2409:                if(p < &key[9])
        !          2410:                        *p++ = c;
        !          2411:        }
        !          2412:        *p = 0;
        !          2413:        b.sg_flags = save;
        !          2414:        stty(0, &b);
        !          2415:        signal(2        , sig);
        !          2416:        return(key[0] != 0);
        !          2417: }
        !          2418: 
        !          2419: 
        !          2420: 
        !          2421: 
        !          2422: 
        !          2423: crinit(keyp, permp)
        !          2424: char   *keyp, *permp;
        !          2425: {
        !          2426:        register char *t1, *t2, *t3;
        !          2427:        register i;
        !          2428:        int ic, k, temp, pf[2];
        !          2429:        unsigned random;
        !          2430:        char buf[13];
        !          2431:        long seed;
        !          2432: 
        !          2433:        t1 = permp;
        !          2434:        t2 = &permp[256];
        !          2435:        t3 = &permp[512];
        !          2436:        if(*keyp == 0)
        !          2437:                return(0);
        !          2438:        strncpy(buf, keyp, 8);
        !          2439:        while (*keyp)
        !          2440:                *keyp++ = '\0';
        !          2441:        buf[8] = buf[0];
        !          2442:        buf[9] = buf[1];
        !          2443:        if (pipe(pf)<0)
        !          2444:                pf[0] = pf[1] = -1;
        !          2445:        if (fork()==0) {
        !          2446:                close(0);
        !          2447:                close(1);
        !          2448:                dup(pf[0]);
        !          2449:                dup(pf[1]);
        !          2450:                execl("/usr/lib/makekey", "-", 0);
        !          2451:                execl("/lib/makekey", "-", 0);
        !          2452:                exit(1);
        !          2453:        }
        !          2454:        write(pf[1], buf, 10);
        !          2455:        if (wait((int *)0)==-1 || read(pf[0], buf, 13)!=13)
        !          2456:                error("crypt: cannot generate key");
        !          2457:        close(pf[0]);
        !          2458:        close(pf[1]);
        !          2459:        seed = 123;
        !          2460:        for (i=0; i<13; i++)
        !          2461:                seed = seed*buf[i] + i;
        !          2462:        for(i=0;i<256;i++){
        !          2463:                t1[i] = i;
        !          2464:                t3[i] = 0;
        !          2465:        }
        !          2466:        for(i=0; i<256; i++) {
        !          2467:                seed = 5*seed + buf[i%13];
        !          2468:                random = seed % 65521;
        !          2469:                k = 256-1 - i;
        !          2470:                ic = (random&0377) % (k+1);
        !          2471:                random >>= 8;
        !          2472:                temp = t1[k];
        !          2473:                t1[k] = t1[ic];
        !          2474:                t1[ic] = temp;
        !          2475:                if(t3[k]!=0) continue;
        !          2476:                ic = (random&0377) % k;
        !          2477:                while(t3[ic]!=0) ic = (ic+1) % k;
        !          2478:                t3[k] = ic;
        !          2479:                t3[ic] = k;
        !          2480:        }
        !          2481:        for(i=0; i<256; i++)
        !          2482:                t2[t1[i]&0377] = i;
        !          2483:        return(1);
        !          2484: }
        !          2485: 
        !          2486: makekey(a, b)
        !          2487: char *a, *b;
        !          2488: {
        !          2489:        register int i;
        !          2490:        long t;
        !          2491:        char temp[9 + 1];
        !          2492: 
        !          2493:        for(i = 0; i < 9; i++)
        !          2494:                temp[i] = *a++;
        !          2495:        time(&t);
        !          2496:        t += getpid();
        !          2497:        for(i = 0; i < 4; i++)
        !          2498:                temp[i] ^= (t>>(8*i))&0377;
        !          2499:        crinit(temp, b);
        !          2500: 
        !          2501: }

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