![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to osed1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / sed|
Return to osed1.c CVS log | Up to [Research Unix] / researchv10dc / cmd / sed |
1.1 root 1: #include <stdio.h>
2: #include "sed.h"
3:
4: #define Read(f, buf, n) (fflush(stdout), read(f, buf, n))
5: char *lformat();
6:
7: execute(file)
8: char *file;
9: {
10: register char *p1, *p2;
11: register union reptr *ipc;
12: int c;
13: long l;
14: char *execp;
15:
16: if (file) {
17: if ((f = open(file, 0)) < 0) {
18: fprintf(stderr, "sed: Can't open %s\n", file);
19: }
20: } else
21: f = 0;
22:
23: ebp = ibuf;
24: cbp = ibuf;
25:
26: if(pending) {
27: ipc = pending;
28: pending = 0;
29: goto yes;
30: }
31:
32: for(;;) {
33: if((execp = gline(linebuf)) == badp) {
34: close(f);
35: return;
36: }
37: spend = execp;
38:
39: for(ipc = ptrspace; ipc->r1.command; ) {
40:
41: p1 = ipc->r1.ad1;
42: p2 = ipc->r1.ad2;
43:
44: if(p1) {
45:
46: if(ipc->r1.inar) {
47: if(*p2 == CEND) {
48: p1 = 0;
49: } else if(*p2 == CLNUM) {
50: l = p2[1]&0377
51: | ((p2[2]&0377)<<8)
52: | ((p2[3]&0377)<<16)
53: | ((p2[4]&0377)<<24);
54: if(lnum > l) {
55: ipc->r1.inar = 0;
56: if(ipc->r1.negfl)
57: goto yes;
58: ipc++;
59: continue;
60: }
61: if(lnum == l) {
62: ipc->r1.inar = 0;
63: }
64: } else if(match(p2, 0)) {
65: ipc->r1.inar = 0;
66: }
67: } else if(*p1 == CEND) {
68: if(!dolflag) {
69: if(ipc->r1.negfl)
70: goto yes;
71: ipc++;
72: continue;
73: }
74:
75: } else if(*p1 == CLNUM) {
76: l = p1[1]&0377
77: | ((p1[2]&0377)<<8)
78: | ((p1[3]&0377)<<16)
79: | ((p1[4]&0377)<<24);
80: if(lnum != l) {
81: if(ipc->r1.negfl)
82: goto yes;
83: ipc++;
84: continue;
85: }
86: if(p2)
87: ipc->r1.inar = 1;
88: } else if(match(p1, 0)) {
89: if(p2)
90: ipc->r1.inar = 1;
91: } else {
92: if(ipc->r1.negfl)
93: goto yes;
94: ipc++;
95: continue;
96: }
97: }
98:
99: if(ipc->r1.negfl) {
100: ipc++;
101: continue;
102: }
103: yes:
104: command(ipc);
105:
106: if(delflag)
107: break;
108:
109: if(jflag) {
110: jflag = 0;
111: if((ipc = ipc->r2.lb1) == 0) {
112: ipc = ptrspace;
113: break;
114: }
115: } else
116: ipc++;
117:
118: }
119: if(!nflag && !delflag) {
120: for(p1 = linebuf; p1 < spend; p1++)
121: putc(*p1, stdout);
122: putc('\n', stdout);
123: }
124:
125: if(aptr > abuf) {
126: arout();
127: }
128:
129: delflag = 0;
130:
131: }
132: }
133: match(expbuf, gf)
134: char *expbuf;
135: {
136: register char *p1, *p2, c;
137:
138: if(gf) {
139: if(*expbuf) return(0);
140: p1 = linebuf;
141: p2 = genbuf;
142: while(*p1++ = *p2++);
143: locs = p1 = loc2;
144: } else {
145: p1 = linebuf;
146: locs = 0;
147: }
148:
149: p2 = expbuf;
150: if(*p2++) {
151: loc1 = p1;
152: if(*p2 == CCHR && p2[1] != *p1)
153: return(0);
154: return(advance(p1, p2));
155: }
156:
157: /* fast check for first character */
158:
159: if(*p2 == CCHR) {
160: c = p2[1];
161: do {
162: if(*p1 != c)
163: continue;
164: if(advance(p1, p2)) {
165: loc1 = p1;
166: return(1);
167: }
168: } while(*p1++);
169: return(0);
170: }
171:
172: do {
173: if(advance(p1, p2)) {
174: loc1 = p1;
175: return(1);
176: }
177: } while(*p1++);
178: return(0);
179: }
180: advance(alp, aep)
181: char *alp, *aep;
182: {
183: register char *lp, *ep, *curlp;
184: char c;
185: char *bbeg;
186: int ct;
187:
188: /*fprintf(stderr, "*lp = %c, %o\n*ep = %c, %o\n", *lp, *lp, *ep, *ep); /*DEBUG*/
189:
190: lp = alp;
191: ep = aep;
192: for (;;) switch (*ep++) {
193:
194: case CCHR:
195: if (*ep++ == *lp++)
196: continue;
197: return(0);
198:
199: case CDOT:
200: if (*lp++)
201: continue;
202: return(0);
203:
204: case CNL:
205: case CDOL:
206: if (*lp == 0)
207: continue;
208: return(0);
209:
210: case CEOF:
211: loc2 = lp;
212: return(1);
213:
214: case CCL:
215: c = *lp++ & 0177;
216: if(ep[c>>3] & bittab[c & 07]) {
217: ep += 16;
218: continue;
219: }
220: return(0);
221:
222: case CBRA:
223: braslist[*ep++] = lp;
224: continue;
225:
226: case CKET:
227: braelist[*ep++] = lp;
228: continue;
229:
230: case CBACK:
231: bbeg = braslist[*ep];
232: ct = braelist[*ep++] - bbeg;
233:
234: if(ecmp(bbeg, lp, ct)) {
235: lp += ct;
236: continue;
237: }
238: return(0);
239:
240: case CBACK|STAR:
241: bbeg = braslist[*ep];
242: ct = braelist[*ep++] - bbeg;
243: curlp = lp;
244: while(ecmp(bbeg, lp, ct))
245: lp += ct;
246:
247: while(lp >= curlp) {
248: if(advance(lp, ep)) return(1);
249: lp -= ct;
250: }
251: return(0);
252:
253:
254: case CDOT|STAR:
255: curlp = lp;
256: while (*lp++);
257: goto star;
258:
259: case CCHR|STAR:
260: curlp = lp;
261: while (*lp++ == *ep);
262: ep++;
263: goto star;
264:
265: case CCL|STAR:
266: curlp = lp;
267: do {
268: c = *lp++ & 0177;
269: } while(ep[c>>3] & bittab[c & 07]);
270: ep += 16;
271: goto star;
272:
273: star:
274: if(--lp == curlp) {
275: continue;
276: }
277:
278: if(*ep == CCHR) {
279: c = ep[1];
280: do {
281: if(*lp != c)
282: continue;
283: if(advance(lp, ep))
284: return(1);
285: } while(lp-- > curlp);
286: return(0);
287: }
288:
289: if(*ep == CBACK) {
290: c = *(braslist[ep[1]]);
291: do {
292: if(*lp != c)
293: continue;
294: if(advance(lp, ep))
295: return(1);
296: } while(lp-- > curlp);
297: return(0);
298: }
299:
300: do {
301: if(lp == locs) break;
302: if (advance(lp, ep))
303: return(1);
304: } while (lp-- > curlp);
305: return(0);
306:
307: default:
308: fprintf(stderr, "sed: RE botch, %o\n", *--ep);
309: exit(1);
310: }
311: }
312: substitute(ipc)
313: union reptr *ipc;
314: {
315: register char *oloc2;
316:
317: if(match(ipc->r1.re1, 0)) {
318:
319: sflag = 1;
320: if(!ipc->r1.gfl) {
321: dosub(ipc->r1.rhs);
322: return(1);
323: }
324:
325: oloc2 = NULL;
326: do {
327: if(oloc2 == loc2) {
328: loc2++;
329: continue;
330: } else {
331: dosub(ipc->r1.rhs);
332: if(*loc2 == 0)
333: break;
334: oloc2 = loc2;
335: }
336: } while(match(ipc->r1.re1, 1));
337: return(1);
338: }
339: return(0);
340: }
341:
342: dosub(rhsbuf)
343: char *rhsbuf;
344: {
345: register char *lp, *sp, *rp;
346: int c;
347:
348: lp = linebuf;
349: sp = genbuf;
350: rp = rhsbuf;
351: while (lp < loc1)
352: *sp++ = *lp++;
353: while(c = *rp++) {
354: if (c == '&') {
355: sp = place(sp, loc1, loc2);
356: continue;
357: } else if (c&0200 && (c &= 0177) >= '1' && c < NBRA+'1') {
358: sp = place(sp, braslist[c-'1'], braelist[c-'1']);
359: continue;
360: }
361: *sp++ = c&0177;
362: if (sp >= &genbuf[LBSIZE])
363: fprintf(stderr, "sed: Output line too long.\n");
364: }
365: lp = loc2;
366: loc2 = sp - genbuf + linebuf;
367: while (*sp++ = *lp++)
368: if (sp >= &genbuf[LBSIZE]) {
369: fprintf(stderr, "sed: Output line too long.\n");
370: }
371: lp = linebuf;
372: sp = genbuf;
373: while (*lp++ = *sp++);
374: spend = lp-1;
375: }
376: char *place(asp, al1, al2)
377: char *asp, *al1, *al2;
378: {
379: register char *sp, *l1, *l2;
380:
381: sp = asp;
382: l1 = al1;
383: l2 = al2;
384: while (l1 < l2) {
385: *sp++ = *l1++;
386: if (sp >= &genbuf[LBSIZE])
387: fprintf(stderr, "sed: Output line too long.\n");
388: }
389: return(sp);
390: }
391:
392: command(ipc)
393: union reptr *ipc;
394: {
395: register int i;
396: register char *p1, *p2;
397: char *execp;
398:
399:
400: switch(ipc->r1.command) {
401:
402: case ACOM:
403: *aptr++ = ipc;
404: if(aptr >= &abuf[ABUFSIZE]) {
405: fprintf(stderr, "sed: Too many appends after line %ld\n",
406: lnum);
407: }
408: *aptr = 0;
409: break;
410:
411: case CCOM:
412: delflag = 1;
413: if(!ipc->r1.inar || dolflag) {
414: for(p1 = ipc->r1.re1; *p1; )
415: putc(*p1++, stdout);
416: putc('\n', stdout);
417: }
418: break;
419: case DCOM:
420: delflag++;
421: break;
422: case CDCOM:
423: p1 = p2 = linebuf;
424:
425: while(*p1 != '\n') {
426: if(*p1++ == 0) {
427: delflag++;
428: return;
429: }
430: }
431:
432: p1++;
433: while(*p2++ = *p1++);
434: spend = p2-1;
435: jflag++;
436: break;
437:
438: case EQCOM:
439: fprintf(stdout, "%ld\n", lnum);
440: break;
441:
442: case GCOM:
443: p1 = linebuf;
444: p2 = holdsp;
445: while(*p1++ = *p2++);
446: spend = p1-1;
447: break;
448:
449: case CGCOM:
450: *spend++ = '\n';
451: p1 = spend;
452: p2 = holdsp;
453: while(*p1++ = *p2++)
454: if(p1 >= lbend)
455: break;
456: spend = p1-1;
457: break;
458:
459: case HCOM:
460: p1 = holdsp;
461: p2 = linebuf;
462: while(*p1++ = *p2++);
463: hspend = p1-1;
464: break;
465:
466: case CHCOM:
467: *hspend++ = '\n';
468: p1 = hspend;
469: p2 = linebuf;
470: while(*p1++ = *p2++)
471: if(p1 >= hend)
472: break;
473: hspend = p1-1;
474: break;
475:
476: case ICOM:
477: for(p1 = ipc->r1.re1; *p1; )
478: putc(*p1++, stdout);
479: putc('\n', stdout);
480: break;
481:
482: case BCOM:
483: jflag = 1;
484: break;
485:
486: case LCOM:
487: p1 = linebuf;
488: p2 = genbuf;
489: while(*p1) {
490: p2 = lformat(*p1++ & 0377, p2);
491: if(p2>lcomend && *p1) {
492: *p2 = 0;
493: fprintf(stdout, "%s\\\n", genbuf);
494: p2 = genbuf;
495: }
496: }
497: if(p2>genbuf && (p1[-1]==' '||p1[-1]=='\n'))
498: p2 = lformat('\n', p2);
499: *p2 = 0;
500: fprintf(stdout, "%s\n", genbuf);
501: break;
502:
503: case NCOM:
504: if(!nflag) {
505: for(p1 = linebuf; p1 < spend; p1++)
506: putc(*p1, stdout);
507: putc('\n', stdout);
508: }
509:
510: if(aptr > abuf)
511: arout();
512: if((execp = gline(linebuf)) == badp) {
513: pending = ipc;
514: delflag = 1;
515: break;
516: }
517: spend = execp;
518:
519: break;
520: case CNCOM:
521: if(aptr > abuf)
522: arout();
523: *spend++ = '\n';
524: if((execp = gline(spend)) == badp) {
525: pending = ipc;
526: delflag = 1;
527: break;
528: }
529: spend = execp;
530: break;
531:
532: case PCOM:
533: for(p1 = linebuf; p1 < spend; p1++)
534: putc(*p1, stdout);
535: putc('\n', stdout);
536: break;
537: case CPCOM:
538: cpcom:
539: for(p1 = linebuf; *p1 != '\n' && *p1 != '\0'; )
540: putc(*p1++, stdout);
541: putc('\n', stdout);
542: break;
543:
544: case QCOM:
545: if(!nflag) {
546: for(p1 = linebuf; p1 < spend; p1++)
547: putc(*p1, stdout);
548: putc('\n', stdout);
549: }
550: if(aptr > abuf) arout();
551: fclose(stdout);
552: lseek(f,(long)(cbp-ebp),2);
553: exit(0);
554: case RCOM:
555:
556: *aptr++ = ipc;
557: if(aptr >= &abuf[ABUFSIZE])
558: fprintf(stderr, "sed: Too many reads after line%ld\n",
559: lnum);
560:
561: *aptr = 0;
562:
563: break;
564:
565: case SCOM:
566: i = substitute(ipc);
567: if(ipc->r1.pfl && i)
568: if(ipc->r1.pfl == 1) {
569: for(p1 = linebuf; p1 < spend; p1++)
570: putc(*p1, stdout);
571: putc('\n', stdout);
572: }
573: else
574: goto cpcom;
575: if(i && ipc->r1.fcode)
576: goto wcom;
577: break;
578:
579: case TCOM:
580: if(sflag == 0) break;
581: sflag = 0;
582: jflag = 1;
583: break;
584:
585: wcom:
586: case WCOM:
587: fprintf(ipc->r1.fcode, "%s\n", linebuf);
588: fflush(ipc->r1.fcode);
589: break;
590: case XCOM:
591: p1 = linebuf;
592: p2 = genbuf;
593: while(*p2++ = *p1++);
594: p1 = holdsp;
595: p2 = linebuf;
596: while(*p2++ = *p1++);
597: spend = p2 - 1;
598: p1 = genbuf;
599: p2 = holdsp;
600: while(*p2++ = *p1++);
601: hspend = p2 - 1;
602: break;
603:
604: case YCOM:
605: p1 = linebuf;
606: p2 = ipc->r1.re1;
607: while(*p1 = p2[*p1]) p1++;
608: break;
609: }
610:
611: }
612:
613: char *
614: gline(addr)
615: char *addr;
616: {
617: register char *p1, *p2;
618: register c;
619: sflag = 0;
620: p1 = addr;
621: p2 = cbp;
622: for (;;) {
623: if (p2 >= ebp) {
624: if ((c = Read(f, ibuf, 512)) <= 0) {
625: return(badp);
626: }
627: p2 = ibuf;
628: ebp = ibuf+c;
629: }
630: if ((c = *p2++) == '\n') {
631: if(p2 >= ebp) {
632: if((c = Read(f, ibuf, 512)) <= 0) {
633: close(f);
634: if(eargc == 0)
635: dolflag = 1;
636: }
637:
638: p2 = ibuf;
639: ebp = ibuf + c;
640: }
641: break;
642: }
643: if(c)
644: if(p1 < lbend)
645: *p1++ = c;
646: }
647: lnum++;
648: *p1 = 0;
649: cbp = p2;
650:
651: return(p1);
652: }
653: ecmp(a, b, count)
654: char *a, *b;
655: {
656: while(count--)
657: if(*a++ != *b++) return(0);
658: return(1);
659: }
660:
661: arout()
662: {
663: register char *p1;
664: FILE *fi;
665: char c;
666: int t;
667:
668: aptr = abuf - 1;
669: while(*++aptr) {
670: if((*aptr)->r1.command == ACOM) {
671: for(p1 = (*aptr)->r1.re1; *p1; )
672: putc(*p1++, stdout);
673: putc('\n', stdout);
674: } else {
675: if((fi = fopen((*aptr)->r1.re1, "r")) == NULL)
676: continue;
677: while((t = getc(fi)) != EOF) {
678: c = t;
679: putc(c, stdout);
680: }
681: fclose(fi);
682: }
683: }
684: aptr = abuf;
685: *aptr = 0;
686: }
687:
688: char *
689: lformat(c, p)
690: char *p;
691: {
692: int trans =
693: c=='\b'? 'b':
694: c=='\t'? 't':
695: c=='\n'? 'n':
696: c=='\v'? 'v':
697: c=='\f'? 'f':
698: c=='\r'? 'r':
699: c=='\\'? '\\':
700: 0;
701: if(trans) {
702: *p++ = '\\';
703: *p++ = trans;
704: } else if(c<040 || c>=0177) {
705: *p++ = '\\';
706: *p++ = ((c>>6)&07) + '0';
707: *p++ = ((c>>3)&07) + '0';
708: *p++ = (c&07) + '0';
709: } else
710: *p++ = c;
711: return p;
712: }
713:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.