![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_re.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / ex|
Return to ex_re.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / ex |
1.1 root 1: /* Copyright (c) 1980 Regents of the University of California */
2: static char *sccsid = "@(#)ex_re.c 6.2 10/23/80";
3: #include "ex.h"
4: #include "ex_re.h"
5:
6: /*
7: * Global, substitute and regular expressions.
8: * Very similar to ed, with some re extensions and
9: * confirmed substitute.
10: */
11: global(k)
12: bool k;
13: {
14: register char *gp;
15: register int c;
16: register line *a1;
17: char globuf[GBSIZE], *Cwas;
18: int lines = lineDOL();
19: int oinglobal = inglobal;
20: char *oglobp = globp;
21:
22: Cwas = Command;
23: /*
24: * States of inglobal:
25: * 0: ordinary - not in a global command.
26: * 1: text coming from some buffer, not tty.
27: * 2: like 1, but the source of the buffer is a global command.
28: * Hence you're only in a global command if inglobal==2. This
29: * strange sounding convention is historically derived from
30: * everybody simulating a global command.
31: */
32: if (inglobal==2)
33: error("Global within global@not allowed");
34: markDOT();
35: setall();
36: nonzero();
37: if (skipend())
38: error("Global needs re|Missing regular expression for global");
39: c = getchar();
40: ignore(compile(c, 1));
41: savere(scanre);
42: gp = globuf;
43: while ((c = getchar()) != '\n') {
44: switch (c) {
45:
46: case EOF:
47: c = '\n';
48: goto brkwh;
49:
50: case '\\':
51: c = getchar();
52: switch (c) {
53:
54: case '\\':
55: ungetchar(c);
56: break;
57:
58: case '\n':
59: break;
60:
61: default:
62: *gp++ = '\\';
63: break;
64: }
65: break;
66: }
67: *gp++ = c;
68: if (gp >= &globuf[GBSIZE - 2])
69: error("Global command too long");
70: }
71: brkwh:
72: ungetchar(c);
73: out:
74: newline();
75: *gp++ = c;
76: *gp++ = 0;
77: saveall();
78: inglobal = 2;
79: for (a1 = one; a1 <= dol; a1++) {
80: *a1 &= ~01;
81: if (a1 >= addr1 && a1 <= addr2 && execute(0, a1) == k)
82: *a1 |= 01;
83: }
84: #ifdef notdef
85: /*
86: * This code is commented out for now. The problem is that we don't
87: * fix up the undo area the way we should. Basically, I think what has
88: * to be done is to copy the undo area down (since we shrunk everything)
89: * and move the various pointers into it down too. I will do this later
90: * when I have time. (Mark, 10-20-80)
91: */
92: /*
93: * Special case: g/.../d (avoid n^2 algorithm)
94: */
95: if (globuf[0]=='d' && globuf[1]=='\n' && globuf[2]=='\0') {
96: gdelete();
97: return;
98: }
99: #endif
100: if (inopen)
101: inopen = -1;
102: /*
103: * Now for each marked line, set dot there and do the commands.
104: * Note the n^2 behavior here for lots of lines matching.
105: * This is really needed: in some cases you could delete lines,
106: * causing a marked line to be moved before a1 and missed if
107: * we didn't restart at zero each time.
108: */
109: for (a1 = one; a1 <= dol; a1++) {
110: if (*a1 & 01) {
111: *a1 &= ~01;
112: dot = a1;
113: globp = globuf;
114: commands(1, 1);
115: a1 = zero;
116: }
117: }
118: globp = oglobp;
119: inglobal = oinglobal;
120: endline = 1;
121: Command = Cwas;
122: netchHAD(lines);
123: setlastchar(EOF);
124: if (inopen) {
125: ungetchar(EOF);
126: inopen = 1;
127: }
128: }
129:
130: /*
131: * gdelete: delete inside a global command. Handles the
132: * special case g/r.e./d. All lines to be deleted have
133: * already been marked. Squeeze the remaining lines together.
134: * Note that other cases such as g/r.e./p, g/r.e./s/r.e.2/rhs/,
135: * and g/r.e./.,/r.e.2/d are not treated specially. There is no
136: * good reason for this except the question: where to you draw the line?
137: */
138: gdelete()
139: {
140: register line *a1, *a2, *a3;
141:
142: a3 = dol;
143: /* find first marked line. can skip all before it */
144: for (a1=zero; (*a1&01)==0; a1++)
145: if (a1>=a3)
146: return;
147: /* copy down unmarked lines, compacting as we go. */
148: for (a2=a1+1; a2<=a3;) {
149: if (*a2&01) {
150: a2++; /* line is marked, skip it */
151: dot = a1; /* dot left after line deletion */
152: } else
153: *a1++ = *a2++; /* unmarked, copy it */
154: }
155: dol = a1-1;
156: if (dot>dol)
157: dot = dol;
158: change();
159: }
160:
161: bool cflag;
162: int scount, slines, stotal;
163:
164: substitute(c)
165: int c;
166: {
167: register line *addr;
168: register int n;
169: int gsubf, hopcount = 0;
170:
171: gsubf = compsub(c);
172: if(FIXUNDO)
173: save12(), undkind = UNDCHANGE;
174: stotal = 0;
175: slines = 0;
176: for (addr = addr1; addr <= addr2; addr++) {
177: scount = 0;
178: if (dosubcon(0, addr) == 0)
179: continue;
180: if (gsubf) {
181: /*
182: * The loop can happen from s/\</&/g
183: * but we don't want to break other, reasonable cases.
184: */
185: while (*loc2) {
186: if (++hopcount > sizeof linebuf)
187: error("substitution loop");
188: if (dosubcon(1, addr) == 0)
189: break;
190: }
191: }
192: if (scount) {
193: stotal += scount;
194: slines++;
195: putmark(addr);
196: n = append(getsub, addr);
197: addr += n;
198: addr2 += n;
199: }
200: }
201: if (stotal == 0 && !inglobal && !cflag)
202: error("Fail|Substitute pattern match failed");
203: snote(stotal, slines);
204: return (stotal);
205: }
206:
207: compsub(ch)
208: {
209: register int seof, c, uselastre;
210: static int gsubf;
211:
212: if (!value(EDCOMPATIBLE))
213: gsubf = cflag = 0;
214: uselastre = 0;
215: switch (ch) {
216:
217: case 's':
218: ignore(skipwh());
219: seof = getchar();
220: if (endcmd(seof) || any(seof, "gcr")) {
221: ungetchar(seof);
222: goto redo;
223: }
224: if (isalpha(seof) || isdigit(seof))
225: error("Substitute needs re|Missing regular expression for substitute");
226: seof = compile(seof, 1);
227: uselastre = 1;
228: comprhs(seof);
229: gsubf = 0;
230: cflag = 0;
231: break;
232:
233: case '~':
234: uselastre = 1;
235: /* fall into ... */
236: case '&':
237: redo:
238: if (re.Expbuf[0] == 0)
239: error("No previous re|No previous regular expression");
240: if (subre.Expbuf[0] == 0)
241: error("No previous substitute re|No previous substitute to repeat");
242: break;
243: }
244: for (;;) {
245: c = getchar();
246: switch (c) {
247:
248: case 'g':
249: gsubf = !gsubf;
250: continue;
251:
252: case 'c':
253: cflag = !cflag;
254: continue;
255:
256: case 'r':
257: uselastre = 1;
258: continue;
259:
260: default:
261: ungetchar(c);
262: setcount();
263: newline();
264: if (uselastre)
265: savere(subre);
266: else
267: resre(subre);
268: return (gsubf);
269: }
270: }
271: }
272:
273: comprhs(seof)
274: int seof;
275: {
276: register char *rp, *orp;
277: register int c;
278: char orhsbuf[RHSSIZE];
279:
280: rp = rhsbuf;
281: CP(orhsbuf, rp);
282: for (;;) {
283: c = getchar();
284: if (c == seof)
285: break;
286: switch (c) {
287:
288: case '\\':
289: c = getchar();
290: if (c == EOF) {
291: ungetchar(c);
292: break;
293: }
294: if (value(MAGIC)) {
295: /*
296: * When "magic", \& turns into a plain &,
297: * and all other chars work fine quoted.
298: */
299: if (c != '&')
300: c |= QUOTE;
301: break;
302: }
303: magic:
304: if (c == '~') {
305: for (orp = orhsbuf; *orp; *rp++ = *orp++)
306: if (rp >= &rhsbuf[RHSSIZE - 1])
307: goto toobig;
308: continue;
309: }
310: c |= QUOTE;
311: break;
312:
313: case '\n':
314: case EOF:
315: if (!(globp && globp[0])) {
316: ungetchar(c);
317: goto endrhs;
318: }
319:
320: case '~':
321: case '&':
322: if (value(MAGIC))
323: goto magic;
324: break;
325: }
326: if (rp >= &rhsbuf[RHSSIZE - 1]) {
327: toobig:
328: *rp = 0;
329: error("Replacement pattern too long@- limit 256 characters");
330: }
331: *rp++ = c;
332: }
333: endrhs:
334: *rp++ = 0;
335: }
336:
337: getsub()
338: {
339: register char *p;
340:
341: if ((p = linebp) == 0)
342: return (EOF);
343: strcLIN(p);
344: linebp = 0;
345: return (0);
346: }
347:
348: dosubcon(f, a)
349: bool f;
350: line *a;
351: {
352:
353: if (execute(f, a) == 0)
354: return (0);
355: if (confirmed(a)) {
356: dosub();
357: scount++;
358: }
359: return (1);
360: }
361:
362: confirmed(a)
363: line *a;
364: {
365: register int c, ch;
366:
367: if (cflag == 0)
368: return (1);
369: pofix();
370: pline(lineno(a));
371: if (inopen)
372: putchar('\n' | QUOTE);
373: c = column(loc1 - 1);
374: ugo(c - 1 + (inopen ? 1 : 0), ' ');
375: ugo(column(loc2 - 1) - c, '^');
376: flush();
377: ch = c = getkey();
378: again:
379: if (c == '\r')
380: c = '\n';
381: if (inopen)
382: putchar(c), flush();
383: if (c != '\n' && c != EOF) {
384: c = getkey();
385: goto again;
386: }
387: noteinp();
388: return (ch == 'y');
389: }
390:
391: getch()
392: {
393: char c;
394:
395: if (read(2, &c, 1) != 1)
396: return (EOF);
397: return (c & TRIM);
398: }
399:
400: ugo(cnt, with)
401: int with;
402: int cnt;
403: {
404:
405: if (cnt > 0)
406: do
407: putchar(with);
408: while (--cnt > 0);
409: }
410:
411: int casecnt;
412: bool destuc;
413:
414: dosub()
415: {
416: register char *lp, *sp, *rp;
417: int c;
418:
419: lp = linebuf;
420: sp = genbuf;
421: rp = rhsbuf;
422: while (lp < loc1)
423: *sp++ = *lp++;
424: casecnt = 0;
425: while (c = *rp++) {
426: if (c & QUOTE)
427: switch (c & TRIM) {
428:
429: case '&':
430: sp = place(sp, loc1, loc2);
431: if (sp == 0)
432: goto ovflo;
433: continue;
434:
435: case 'l':
436: casecnt = 1;
437: destuc = 0;
438: continue;
439:
440: case 'L':
441: casecnt = LBSIZE;
442: destuc = 0;
443: continue;
444:
445: case 'u':
446: casecnt = 1;
447: destuc = 1;
448: continue;
449:
450: case 'U':
451: casecnt = LBSIZE;
452: destuc = 1;
453: continue;
454:
455: case 'E':
456: case 'e':
457: casecnt = 0;
458: continue;
459: }
460: if (c < 0 && (c &= TRIM) >= '1' && c < nbra + '1') {
461: sp = place(sp, braslist[c - '1'], braelist[c - '1']);
462: if (sp == 0)
463: goto ovflo;
464: continue;
465: }
466: if (casecnt)
467: *sp++ = fixcase(c & TRIM);
468: else
469: *sp++ = c & TRIM;
470: if (sp >= &genbuf[LBSIZE])
471: ovflo:
472: error("Line overflow@in substitute");
473: }
474: lp = loc2;
475: loc2 = sp + (linebuf - genbuf);
476: while (*sp++ = *lp++)
477: if (sp >= &genbuf[LBSIZE])
478: goto ovflo;
479: strcLIN(genbuf);
480: }
481:
482: fixcase(c)
483: register int c;
484: {
485:
486: if (casecnt == 0)
487: return (c);
488: casecnt--;
489: if (destuc) {
490: if (islower(c))
491: c = toupper(c);
492: } else
493: if (isupper(c))
494: c = tolower(c);
495: return (c);
496: }
497:
498: char *
499: place(sp, l1, l2)
500: register char *sp, *l1, *l2;
501: {
502:
503: while (l1 < l2) {
504: *sp++ = fixcase(*l1++);
505: if (sp >= &genbuf[LBSIZE])
506: return (0);
507: }
508: return (sp);
509: }
510:
511: snote(total, lines)
512: register int total, lines;
513: {
514:
515: if (!notable(total))
516: return;
517: printf(mesg("%d subs|%d substitutions"), total);
518: if (lines != 1 && lines != total)
519: printf(" on %d lines", lines);
520: noonl();
521: flush();
522: }
523:
524: compile(eof, oknl)
525: int eof;
526: int oknl;
527: {
528: register int c;
529: register char *ep;
530: char *lastep;
531: char bracket[NBRA], *bracketp, *rhsp;
532: int cclcnt;
533:
534: if (isalpha(eof) || isdigit(eof))
535: error("Regular expressions cannot be delimited by letters or digits");
536: ep = expbuf;
537: c = getchar();
538: if (eof == '\\')
539: switch (c) {
540:
541: case '/':
542: case '?':
543: if (scanre.Expbuf[0] == 0)
544: error("No previous scan re|No previous scanning regular expression");
545: resre(scanre);
546: return (c);
547:
548: case '&':
549: if (subre.Expbuf[0] == 0)
550: error("No previous substitute re|No previous substitute regular expression");
551: resre(subre);
552: return (c);
553:
554: default:
555: error("Badly formed re|Regular expression \\ must be followed by / or ?");
556: }
557: if (c == eof || c == '\n' || c == EOF) {
558: if (*ep == 0)
559: error("No previous re|No previous regular expression");
560: if (c == '\n' && oknl == 0)
561: error("Missing closing delimiter@for regular expression");
562: if (c != eof)
563: ungetchar(c);
564: return (eof);
565: }
566: bracketp = bracket;
567: nbra = 0;
568: circfl = 0;
569: if (c == '^') {
570: c = getchar();
571: circfl++;
572: }
573: ungetchar(c);
574: for (;;) {
575: if (ep >= &expbuf[ESIZE - 2])
576: complex:
577: cerror("Re too complex|Regular expression too complicated");
578: c = getchar();
579: if (c == eof || c == EOF) {
580: if (bracketp != bracket)
581: cerror("Unmatched \\(|More \\('s than \\)'s in regular expression");
582: *ep++ = CEOFC;
583: if (c == EOF)
584: ungetchar(c);
585: return (eof);
586: }
587: if (value(MAGIC)) {
588: if (c != '*' || ep == expbuf)
589: lastep = ep;
590: } else
591: if (c != '\\' || peekchar() != '*' || ep == expbuf)
592: lastep = ep;
593: switch (c) {
594:
595: case '\\':
596: c = getchar();
597: switch (c) {
598:
599: case '(':
600: if (nbra >= NBRA)
601: cerror("Awash in \\('s!|Too many \\('d subexressions in a regular expression");
602: *bracketp++ = nbra;
603: *ep++ = CBRA;
604: *ep++ = nbra++;
605: continue;
606:
607: case ')':
608: if (bracketp <= bracket)
609: cerror("Extra \\)|More \\)'s than \\('s in regular expression");
610: *ep++ = CKET;
611: *ep++ = *--bracketp;
612: continue;
613:
614: case '<':
615: *ep++ = CBRC;
616: continue;
617:
618: case '>':
619: *ep++ = CLET;
620: continue;
621: }
622: if (value(MAGIC) == 0)
623: magic:
624: switch (c) {
625:
626: case '.':
627: *ep++ = CDOT;
628: continue;
629:
630: case '~':
631: rhsp = rhsbuf;
632: while (*rhsp) {
633: if (*rhsp & QUOTE) {
634: c = *rhsp & TRIM;
635: if (c == '&')
636: error("Replacement pattern contains &@- cannot use in re");
637: if (c >= '1' && c <= '9')
638: error("Replacement pattern contains \\d@- cannot use in re");
639: }
640: if (ep >= &expbuf[ESIZE-2])
641: goto complex;
642: *ep++ = CCHR;
643: *ep++ = *rhsp++ & TRIM;
644: }
645: continue;
646:
647: case '*':
648: if (ep == expbuf)
649: break;
650: if (*lastep == CBRA || *lastep == CKET)
651: cerror("Illegal *|Can't * a \\( ... \\) in regular expression");
652: if (*lastep == CCHR && (lastep[1] & QUOTE))
653: cerror("Illegal *|Can't * a \\n in regular expression");
654: *lastep |= STAR;
655: continue;
656:
657: case '[':
658: *ep++ = CCL;
659: *ep++ = 0;
660: cclcnt = 1;
661: c = getchar();
662: if (c == '^') {
663: c = getchar();
664: ep[-2] = NCCL;
665: }
666: if (c == ']')
667: cerror("Bad character class|Empty character class '[]' or '[^]' cannot match");
668: while (c != ']') {
669: if (c == '\\' && any(peekchar(), "]-^\\"))
670: c = getchar() | QUOTE;
671: if (c == '\n' || c == EOF)
672: cerror("Missing ]");
673: *ep++ = c;
674: cclcnt++;
675: if (ep >= &expbuf[ESIZE])
676: goto complex;
677: c = getchar();
678: }
679: lastep[1] = cclcnt;
680: continue;
681: }
682: if (c == EOF) {
683: ungetchar(EOF);
684: c = '\\';
685: goto defchar;
686: }
687: *ep++ = CCHR;
688: if (c == '\n')
689: cerror("No newlines in re's|Can't escape newlines into regular expressions");
690: /*
691: if (c < '1' || c > NBRA + '1') {
692: */
693: *ep++ = c;
694: continue;
695: /*
696: }
697: c -= '1';
698: if (c >= nbra)
699: cerror("Bad \\n|\\n in regular expression with n greater than the number of \\('s");
700: *ep++ = c | QUOTE;
701: continue;
702: */
703:
704: case '\n':
705: if (oknl) {
706: ungetchar(c);
707: *ep++ = CEOFC;
708: return (eof);
709: }
710: cerror("Badly formed re|Missing closing delimiter for regular expression");
711:
712: case '$':
713: if (peekchar() == eof || peekchar() == EOF || oknl && peekchar() == '\n') {
714: *ep++ = CDOL;
715: continue;
716: }
717: goto defchar;
718:
719: case '.':
720: case '~':
721: case '*':
722: case '[':
723: if (value(MAGIC))
724: goto magic;
725: defchar:
726: default:
727: *ep++ = CCHR;
728: *ep++ = c;
729: continue;
730: }
731: }
732: }
733:
734: cerror(s)
735: char *s;
736: {
737:
738: expbuf[0] = 0;
739: error(s);
740: }
741:
742: same(a, b)
743: register int a, b;
744: {
745:
746: return (a == b || value(IGNORECASE) &&
747: ((islower(a) && toupper(a) == b) || (islower(b) && toupper(b) == a)));
748: }
749:
750: char *locs;
751:
752: execute(gf, addr)
753: line *addr;
754: {
755: register char *p1, *p2;
756: register int c;
757:
758: if (gf) {
759: if (circfl)
760: return (0);
761: locs = p1 = loc2;
762: } else {
763: if (addr == zero)
764: return (0);
765: p1 = linebuf;
766: getline(*addr);
767: locs = 0;
768: }
769: p2 = expbuf;
770: if (circfl) {
771: loc1 = p1;
772: return (advance(p1, p2));
773: }
774: /* fast check for first character */
775: if (*p2 == CCHR) {
776: c = p2[1];
777: do {
778: if (c != *p1 && (!value(IGNORECASE) ||
779: !((islower(c) && toupper(c) == *p1) ||
780: (islower(*p1) && toupper(*p1) == c))))
781: continue;
782: if (advance(p1, p2)) {
783: loc1 = p1;
784: return (1);
785: }
786: } while (*p1++);
787: return (0);
788: }
789: /* regular algorithm */
790: do {
791: if (advance(p1, p2)) {
792: loc1 = p1;
793: return (1);
794: }
795: } while (*p1++);
796: return (0);
797: }
798:
799: #define uletter(c) (isalpha(c) || c == '_')
800:
801: advance(lp, ep)
802: register char *lp, *ep;
803: {
804: register char *curlp;
805: char *sp, *sp1;
806: int c;
807:
808: for (;;) switch (*ep++) {
809:
810: case CCHR:
811: /* useless
812: if (*ep & QUOTE) {
813: c = *ep++ & TRIM;
814: sp = braslist[c];
815: sp1 = braelist[c];
816: while (sp < sp1) {
817: if (!same(*sp, *lp))
818: return (0);
819: sp++, lp++;
820: }
821: continue;
822: }
823: */
824: if (!same(*ep, *lp))
825: return (0);
826: ep++, lp++;
827: continue;
828:
829: case CDOT:
830: if (*lp++)
831: continue;
832: return (0);
833:
834: case CDOL:
835: if (*lp == 0)
836: continue;
837: return (0);
838:
839: case CEOFC:
840: loc2 = lp;
841: return (1);
842:
843: case CCL:
844: if (cclass(ep, *lp++, 1)) {
845: ep += *ep;
846: continue;
847: }
848: return (0);
849:
850: case NCCL:
851: if (cclass(ep, *lp++, 0)) {
852: ep += *ep;
853: continue;
854: }
855: return (0);
856:
857: case CBRA:
858: braslist[*ep++] = lp;
859: continue;
860:
861: case CKET:
862: braelist[*ep++] = lp;
863: continue;
864:
865: case CDOT|STAR:
866: curlp = lp;
867: while (*lp++)
868: continue;
869: goto star;
870:
871: case CCHR|STAR:
872: curlp = lp;
873: while (same(*lp, *ep))
874: lp++;
875: lp++;
876: ep++;
877: goto star;
878:
879: case CCL|STAR:
880: case NCCL|STAR:
881: curlp = lp;
882: while (cclass(ep, *lp++, ep[-1] == (CCL|STAR)))
883: continue;
884: ep += *ep;
885: goto star;
886: star:
887: do {
888: lp--;
889: if (lp == locs)
890: break;
891: if (advance(lp, ep))
892: return (1);
893: } while (lp > curlp);
894: return (0);
895:
896: case CBRC:
897: if (lp == expbuf)
898: continue;
899: if ((isdigit(*lp) || uletter(*lp)) && !uletter(lp[-1]) && !isdigit(lp[-1]))
900: continue;
901: return (0);
902:
903: case CLET:
904: if (!uletter(*lp) && !isdigit(*lp))
905: continue;
906: return (0);
907:
908: default:
909: error("Re internal error");
910: }
911: }
912:
913: cclass(set, c, af)
914: register char *set;
915: register int c;
916: int af;
917: {
918: register int n;
919:
920: if (c == 0)
921: return (0);
922: if (value(IGNORECASE) && isupper(c))
923: c = tolower(c);
924: n = *set++;
925: while (--n)
926: if (n > 2 && set[1] == '-') {
927: if (c >= (set[0] & TRIM) && c <= (set[2] & TRIM))
928: return (af);
929: set += 3;
930: n -= 2;
931: } else
932: if ((*set++ & TRIM) == c)
933: return (af);
934: return (!af);
935: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.