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