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