![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ed3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / ed|
Return to ed3.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / ed |
1.1 root 1: /*
2: * An editor.
3: * Regular expressions and the substitute and global commands.
4: */
5: #include <stdio.h>
6: #include <ctype.h>
7: #include "ed.h"
8:
9: /*
10: * Global command.
11: */
12: global(a1, a2, not)
13: {
14: register int a, c;
15: register char *gp;
16:
17: if (a1>a2 || a1<1 || a2>doladd) {
18: derror("Address out of range");
19: return (0);
20: }
21: if (gcp != NULL) {
22: derror("Global inside global not allowed");
23: return (0);
24: }
25: if ((c=getx()) == '\n') {
26: ungetx(c);
27: derror("Syntax error");
28: return (0);
29: }
30: if (compile(c) == 0)
31: return;
32: gp = globbuf;
33: while ((c=getx()) != '\n') {
34: if (gp >= &globbuf[GBSIZE-3]) {
35: derror("Global buffer overflow");
36: return (0);
37: }
38: if (c == '\\')
39: if ((c=getx())!='\n' && c!='\\')
40: *gp++ = '\\';
41: *gp++ = c;
42: }
43: if (gp == globbuf)
44: goto out;
45: *gp++ = '\n';
46: *gp = '\0';
47: for (a=a1; a<=a2; a++) {
48: if (intflag)
49: goto out;
50: if (execute(a) != not)
51: line[a] |= 1;
52: }
53: a = 1;
54: while (a <= doladd) {
55: if (intflag)
56: goto out;
57: if ((line[a]&1) == 0) {
58: a++;
59: continue;
60: }
61: --line[a];
62: dotadd = a;
63: gcp = globbuf;
64: while (*gcp != '\0')
65: if (command() == 0)
66: goto out;
67: a = 1;
68: }
69: out:
70: for (a=1; a<=doladd; a++)
71: line[a] &= ~1;
72: gcp = NULL;
73: ungetx('\n');
74: return (1);
75: }
76:
77: /*
78: * Substitute part 1.
79: * Check that address range is legal and parse substitute command.
80: */
81: subs1(a1, a2)
82: {
83: register int ec, c;
84: register char *sp;
85:
86: if (a1>a2 || a1<1 || a2>doladd) {
87: derror("Address out of range");
88: return (0);
89: }
90: subnewl = 0;
91: subnths = 1;
92: if (isascii(c=getx()) && isdigit(c)) {
93: subnths = 0;
94: while (isascii(c) && isdigit(c)) {
95: subnths = subnths*10 + c-'0';
96: c = getx();
97: }
98: }
99: if ((ec=c) == '\n') {
100: ungetx(c);
101: derror("Syntax error");
102: return (0);
103: }
104: if (compile(ec) == 0)
105: return (0);
106: sp = subsbuf;
107: while ((c=getx()) != ec) {
108: if (sp >= &subsbuf[SBSIZE-4]) {
109: derror("Temporary buffer overflow");
110: return (0);
111: }
112: switch (c) {
113: case '\n':
114: ungetx(c);
115: derror("Syntax error");
116: return (0);
117: case '&':
118: *sp++ = '\\';
119: *sp++ = '0';
120: continue;
121: case '\\':
122: if ((c=getx()) == '\\') {
123: *sp++ = '\\';
124: *sp++ = '\\';
125: continue;
126: }
127: if (c >= '1' && c <= '9') {
128: *sp++ = '\\';
129: *sp++ = c;
130: continue;
131: }
132: if (c == '\n')
133: subnewl++;
134: default:
135: *sp++ = c;
136: continue;
137: }
138: }
139: *sp++ = '\0';
140: if ((c=getx()) == 'g')
141: subnths = 0;
142: else
143: ungetx(c);
144: return (1);
145: }
146:
147: /*
148: * Substitute (part 2).
149: * Execute substitute command.
150: */
151: subs2(a1, a2)
152: {
153: long seek, mark;
154: int len, nth, err, a;
155: char *mp, *sp;
156: register int n;
157: register char *lp, *rp;
158:
159: err = 1;
160: for (a=a1; a<=a2; a++) {
161: if (intflag)
162: return (1);
163: if (getline(a, tempbuf) == 0)
164: return (0);
165: for (n=0; n<1+BRSIZE; n++) {
166: brace[n].b_bp = NULL;
167: brace[n].b_ep = NULL;
168: }
169: brace[0].b_ep = tempbuf;
170: mp = tempbuf;
171: lp = linebuf;
172: nth = 0;
173: for (;;) {
174: rp = codebuf;
175: if (*rp == CSSOL) {
176: if (mp != tempbuf)
177: break;
178: rp++;
179: }
180: if ((rp=match(mp, rp)) == NULL) {
181: if (*mp++ == '\0')
182: break;
183: continue;
184: }
185: nth++;
186: if (subnths) {
187: if (nth < subnths) {
188: mp = rp;
189: continue;
190: }
191: if (nth > subnths)
192: goto done;
193: }
194: err = 0;
195: saved = 0;
196: dotadd = a;
197: brace[0].b_bp = mp;
198: mp = rp;
199: rp = brace[0].b_ep;
200: brace[0].b_ep = mp;
201: len = mp - brace[0].b_bp;
202: n = brace[0].b_bp - rp;
203: if (lp+n >= &linebuf[LBSIZE-1])
204: goto ovf;
205: while (n--)
206: *lp++ = *rp++;
207: sp = subsbuf;
208: while (*sp) {
209: if (lp >= &linebuf[LBSIZE-4])
210: goto ovf;
211: if (*sp != '\\') {
212: *lp++ = *sp++;
213: continue;
214: }
215: if (*++sp == '\\') {
216: *lp++ = *sp++;
217: continue;
218: }
219: n = *sp++ - '0';
220: if ((rp=brace[n].b_bp) == NULL)
221: continue;
222: n = brace[n].b_ep-rp;
223: if (lp+n >= &linebuf[LBSIZE-4])
224: goto ovf;
225: while (n--)
226: *lp++ = *rp++;
227: }
228: if (*mp == '\0')
229: break;
230: if (len == 0)
231: mp++;
232: if (subnths!=0 && nth==subnths)
233: break;
234: }
235: done:
236: if (dotadd != a)
237: continue;
238: rp = brace[0].b_ep;
239: while (*rp) {
240: if (lp >= &linebuf[LBSIZE-1])
241: goto ovf;
242: *lp++ = *rp++;
243: }
244: *lp++ = '\0';
245: seek = linead();
246: if (subnewl) {
247: lp = linebuf;
248: while (*lp != '\n')
249: lp++;
250: *lp++ = '\0';
251: }
252: if (putline(linebuf, lp-linebuf) == 0)
253: return (0);
254: suborig = line[a];
255: if (suborig&1)
256: --suborig;
257: subseek = seek|1;
258: line[a] = seek;
259: mark = suborig|1;
260: for (n=0; n<MKSIZE; n++)
261: if (marklin[n] == mark)
262: marklin[n] = subseek;
263: if (subnewl != 0) {
264: n = 1;
265: do {
266: mp = lp;
267: while (*lp!='\n' && *lp!='\0')
268: lp++;
269: if (*lp == '\0')
270: n = 0;
271: *lp++ = '\0';
272: seek = linead();
273: if (putline(mp, lp-mp) == 0)
274: return (0);
275: if (expand(a) == 0)
276: return (0);
277: line[++a] = seek;
278: dotadd = a;
279: a2++;
280: } while (n);
281: }
282: }
283: if (err!=0 && gcp==NULL) {
284: derror("Pattern not matched");
285: return (0);
286: }
287: return (1);
288:
289: ovf:
290: derror("Temporary buffer overflow");
291: return (0);
292: }
293:
294: /*
295: * Compile a regular expression. `ec' is the character upon which
296: * the regular expression ends. If an error is encountered, the
297: * pattern is restored and input characters are thrown away until
298: * a new line is found.
299: */
300: compile(ec)
301: {
302: int bstack[BRSIZE], bcount, blevel, n;
303: register int c;
304: register char *cp, *lcp;
305:
306: bcopy(tempbuf, codebuf);
307: bcount = 1;
308: blevel = 0;
309: cp = &codebuf[0];
310: if ((c=getx()) == ec) {
311: if (*cp == CSNUL) {
312: derror("No saved pattern");
313: goto err;
314: }
315: return (1);
316: }
317: if (c == '^') {
318: *cp++ = CSSOL;
319: c = getx();
320: }
321: while (c != ec) {
322: if (c == '\n') {
323: goto nwl;
324: }
325: if (cp > &codebuf[CBSIZE-4])
326: goto ovf;
327: switch (c) {
328: case '*':
329: goto syn;
330: case '.':
331: if ((c=getx()) != '*') {
332: *cp++ = CSDOT;
333: continue;
334: }
335: *cp++ = CMDOT;
336: c = getx();
337: continue;
338: case '$':
339: if ((c=getx()) != ec) {
340: ungetx(c);
341: c = '$';
342: goto character;
343: }
344: *cp++ = CSEOL;
345: continue;
346: case '[':
347: lcp = cp;
348: if ((c=getx()) == '^')
349: *cp++ = CSNCL;
350: else {
351: ungetx(c);
352: *cp++ = CSCCL;
353: }
354: *cp++ = 0;
355: if ((c=getx()) == ']')
356: *cp++ = c;
357: else
358: ungetx(c);
359: while ((c=getx()) != ']') {
360: if (c == '\n')
361: goto nwl;
362: if (c!='-' || cp==lcp+2) {
363: if (cp >= &codebuf[CBSIZE-4])
364: goto ovf;
365: *cp++ = c;
366: if (sflag && isascii(c) && isallet(c))
367: *cp++ = toother(c);
368: continue;
369: }
370: if ((c=getx()) == '\n')
371: goto nwl;
372: if (c == ']') {
373: *cp++ = '-';
374: ungetx(c);
375: continue;
376: }
377: if ((n=cp[-1]) > c)
378: goto syn;
379: while (++n <= c) {
380: if (cp >= &codebuf[CBSIZE-4])
381: goto ovf;
382: *cp++ = n;
383: if (sflag && isascii(c) && isallet(c))
384: *cp++ = toother(c);
385: }
386: }
387: if ((c=getx()) == '*') {
388: (*lcp)++;
389: c = getx();
390: }
391: if ((n=cp-(lcp+2)) > 255) {
392: derror("Character class too large");
393: goto err;
394: }
395: *++lcp = n;
396: continue;
397: case '\\':
398: switch (c=getx()) {
399: case '\n':
400: goto nwl;
401: case '(':
402: if (bcount > BRSIZE) {
403: derror("Too many \\(");
404: goto err;
405: }
406: *cp++ = CSOPR;
407: *cp++ = bstack[blevel++] = bcount++;
408: c = getx();
409: continue;
410: case ')':
411: if (blevel == 0)
412: goto syn;
413: *cp++ = CSCPR;
414: *cp++ = bstack[--blevel];
415: c = getx();
416: continue;
417: default:
418: if (isascii(c) && isdigit(c)) {
419: *cp++ = CSBRN;
420: *cp++ = c-'0';
421: c = getx();
422: continue;
423: }
424: }
425: default:
426: character:
427: if (sflag && isascii(c) && isallet(c)) {
428: *cp++ = CSSCC;
429: if (isupper(c))
430: c = tolower(c);
431: } else
432: *cp++ = CSCHR;
433: *cp++ = c;
434: if ((c=getx()) == '*') {
435: cp[-2]++;
436: c = getx();
437: }
438: }
439: }
440: *cp++ = CSNUL;
441: return (1);
442: ovf:
443: derror("Code buffer overflow");
444: bcopy(codebuf, tempbuf);
445: return (0);
446: nwl:
447: ungetx(c);
448: syn:
449: derror("Syntax error");
450: err:
451: bcopy(codebuf, tempbuf);
452: return (0);
453: }
454:
455: /*
456: * Copy BSIZE buffer into dest from source
457: */
458: bcopy(dest, source)
459: register char *dest;
460: register char *source;
461: {
462: register int n;
463:
464: n = CBSIZE;
465: do
466: *dest++ = *source++;
467: while (--n > 0);
468: }
469:
470: /*
471: * Return 1 if the compiled expression in `codebuf' matches the line in
472: * `linebuf', else 0.
473: */
474: execute(a)
475: {
476: register int i;
477: register char *lp, *ep;
478:
479: if (getline(a, linebuf) == 0)
480: return (0);
481: for (i=0; i<1+BRSIZE; i++) {
482: brace[i].b_bp = NULL;
483: brace[i].b_ep = NULL;
484: }
485: if (codebuf[0] == CSSOL)
486: ep = match(lp=linebuf, &codebuf[1]);
487: else {
488: ep = NULL;
489: lp = linebuf;
490: do {
491: if (ep=match(lp, codebuf))
492: break;
493: } while (*lp++);
494: }
495: if (ep) {
496: brace[0].b_bp = lp;
497: brace[0].b_ep = ep;
498: }
499: return (ep ? 1 : 0);
500: }
501:
502: /*
503: * Given a pointer to a compiled expression, `cp', and a pointer to
504: * a line, `lp', return 1 if the expression matches, else 0.
505: */
506: char *
507: match(lp, cp)
508: register char *lp, *cp;
509: {
510: register int n;
511: char *llp, *lcp;
512:
513: for (;;) {
514: switch (*cp++) {
515: case CSNUL:
516: return (lp);
517: case CSEOL:
518: if (*lp)
519: return (NULL);
520: return (lp);
521: case CSOPR:
522: brace[*cp++].b_bp = lp;
523: continue;
524: case CSCPR:
525: brace[*cp++].b_ep = lp;
526: continue;
527: case CSBRN:
528: n = *cp++;
529: lcp = cp;
530: cp = brace[n].b_bp;
531: n = brace[n].b_ep - cp;
532: if (n > LBSIZE)
533: return (NULL);
534: while (n-- > 0)
535: if (*lp++ != *cp++)
536: return (NULL);
537: cp = lcp;
538: continue;
539: case CSDOT:
540: if (*lp++ == '\0')
541: return (NULL);
542: continue;
543: case CMDOT:
544: llp = lp;
545: while (*lp)
546: lp++;
547: goto star;
548: case CSCHR:
549: if (*cp++ != *lp++)
550: return (NULL);
551: continue;
552: case CMCHR:
553: llp = lp;
554: while (*cp == *lp)
555: lp++;
556: cp++;
557: goto star;
558: case CSSCC:
559: if (*cp++ == tolower(*lp++))
560: continue;
561: return (NULL);
562: case CMSCC:
563: llp = lp;
564: while (*cp == tolower(*lp++))
565: ;
566: cp++;
567: goto star;
568: case CSCCL:
569: n = *cp++;
570: while (*cp++ != *lp)
571: if (--n == 0)
572: return (NULL);
573: lp++;
574: cp += n-1;
575: continue;
576: case CMCCL:
577: llp = lp;
578: lcp = cp;
579: while (*lp) {
580: cp = lcp;
581: n = *cp++;
582: while (*cp++ != *lp)
583: if (--n == 0)
584: goto star;
585: lp++;
586: }
587: cp = lcp + *lcp + 1;
588: goto star;
589: case CSNCL:
590: if (*lp == '\0')
591: return (NULL);
592: n = *cp++;
593: while (n--)
594: if (*cp++ == *lp)
595: return (NULL);
596: lp++;
597: continue;
598: case CMNCL:
599: llp = lp;
600: lcp = cp;
601: while (*lp) {
602: cp = lcp;
603: n = *cp++;
604: while (n--) {
605: if (*cp++ == *lp) {
606: cp = lcp + *lcp + 1;
607: goto star;
608: }
609: }
610: lp++;
611: }
612: cp = lcp + *lcp + 1;
613: star:
614: do {
615: if (lcp=match(lp, cp))
616: return (lcp);
617: } while (--lp >= llp);
618: return (NULL);
619: }
620: }
621: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.