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