![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to egbr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / gre|
Return to egbr.c CVS log | Up to [Research Unix] / researchv10no / cmd / gre |
1.1 root 1: #include "re.h"
2: #include "lre.h"
3: #include "hdr.h"
4:
5: #define DEBUG
6:
7: static Br *seq(Expr *);
8: static Br *spew(Br_type, Expr*, int);
9:
10: static Expr *eop;
11:
12: static char tabs[] = { '\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t',
13: '\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t', 0
14: };
15: #define SPACE(d) (&tabs[sizeof tabs - (d) - 1])
16:
17: static void
18: init1(register Br *br, re_re *r)
19: {
20: switch(br->type)
21: {
22: case br_re:
23: br->r = (re_re *)egmalloc(sizeof(re_re), "egbr");
24: #ifdef DEBUG
25: if(TRACE(3))
26: PR "b@%ld->r = %ld\n", br, br->r);
27: #endif
28: if(!br->r)
29: return;
30: memcpy((char *)br->r, (char *)r, sizeof(*r));
31: if(br->e->type != EOP)
32: br->e = eg_newexpr(EOP, '#', br->e, (Expr *)0);
33: br->r->root = br->e;
34: br->e->id = eop->id;
35: br->r->br = br;
36: br->r->backref = br->r->root->backref;
37: br->r->parens = br->r->root->parens;
38: eginit(br->r, br == r->br);
39: break;
40: case br_star:
41: case br_plus:
42: case br_quest:
43: case br_group:
44: init1(br->lb, r);
45: break;
46: case br_cat:
47: case br_alt:
48: init1(br->lb, r);
49: init1(br->rb, r);
50: break;
51: }
52: }
53:
54: void
55: egbr(re_re *r)
56: {
57: eop = 0;
58: /*
59: #ifdef DEBUG
60: if(1||TRACE(3)){
61: char buf[EPRINTSIZE];
62:
63: eg_epr(r->root, buf, 0);
64: PR "egbr(%s) ->\n", buf);
65: eg_brpr(seq(r->root));
66: }
67: #endif
68: /**/
69: egcanon(r->root);
70: r->br = seq(r->root);
71: #ifdef DEBUG
72: if(TRACE(3)){
73: char buf[EPRINTSIZE];
74:
75: eg_epr(r->root, buf, 0);
76: PR "egbr(%s) ->\n", buf);
77: eg_brpr(r->br);
78: }
79: #endif
80: init1(r->br, r);
81: }
82:
83: #ifdef DEBUG
84: static void
85: brpr1(Br *b, int depth)
86: {
87: char buf[EPRINTSIZE];
88:
89: PR "%s%d@", SPACE(depth), (int)b);
90: switch(b->type)
91: {
92: case br_br:
93: PR "BR %d\n", b->group);
94: break;
95: case br_re:
96: eg_epr((Expr *)b->e, buf, 0);
97: if(((Expr *)b->e)->backref) PR "X");
98: if(((Expr *)b->e)->parens) PR "()");
99: PR "RE/%s/%d\n", buf, (int)b->r);
100: break;
101: case br_group:
102: PR "GROUP %d\n", b->group);
103: brpr1(b->lb, depth+1);
104: break;
105: case br_quest:
106: PR "BR?");
107: brpr1(b->lb, depth+1);
108: break;
109: case br_plus:
110: PR "BR+\n");
111: brpr1(b->lb, depth+1);
112: break;
113: case br_star:
114: PR "BR*\n");
115: brpr1(b->lb, depth+1);
116: break;
117: case br_cat:
118: PR "BR CAT\n");
119: brpr1(b->lb, depth+1);
120: brpr1(b->rb, depth+1);
121: break;
122: case br_alt:
123: PR "BR |\n");
124: brpr1(b->lb, depth+1);
125: brpr1(b->rb, depth+1);
126: break;
127: default:
128: PR "BADTYPE/%d/\n", b->type);
129: break;
130: }
131: }
132:
133: void
134: eg_brpr(Br *br)
135: {
136: brpr1(br, 0);
137: }
138: #endif
139:
140: static Br *
141: seq(Expr *e)
142: {
143: Br *br;
144:
145: if(e->type == EOP)
146: eop = e;
147: if(!e->backref && !e->parens)
148: return(spew(br_re, e, -1));
149: switch(e->type)
150: {
151: case Cat:
152: br = spew(br_cat, (Expr *)0, -1);
153: br->lb = seq(e->l);
154: br->rb = seq(e->r);
155: return(br);
156: case Alternate:
157: br = spew(br_alt, (Expr *)0, -1);
158: br->lb = seq(e->l);
159: br->rb = seq(e->r);
160: return(br);
161: case Star:
162: br = spew(br_star, (Expr *)0, -1);
163: br->lb = seq(e->l);
164: return(br);
165: case Plus:
166: br = spew(br_plus, (Expr *)0, -1);
167: br->lb = seq(e->l);
168: return(br);
169: case Quest:
170: br = spew(br_quest, (Expr *)0, -1);
171: br->lb = seq(e->l);
172: return(br);
173: case Group:
174: br = spew(br_group, (Expr *)0, e->lit);
175: br->lb = seq(e->l);
176: return(br);
177: case Backref:
178: return(spew(br_br, e->l, e->lit));
179: case EOP:
180: return(seq(e->l));
181: default:
182: return(spew(br_re, e, -1));
183: }
184: }
185:
186: static Br *
187: spew(Br_type t, Expr *d, int g)
188: {
189: Br *b;
190:
191: b = (Br *)egmalloc(sizeof(Br), "back ref malloc");
192: if(!b)
193: return(0);
194: b->type = t;
195: b->e = d;
196: b->group = g;
197: b->r = 0;
198: b->rb = b->lb = 0;
199: return(b);
200: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.