2.9BSD - /usr/src/cmd/ed.c

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

Defined functions

Defined variables

Defined macros