![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to regexp.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / library|
Return to regexp.h CVS log | Up to [Research Unix] / researchv10dc / cmd / library |
1.1 root 1: /* headers:regexp.h 1.3 */
2: /* @(#)regexp.h 5.3 u370 source */
3: #define CBRA 2
4: #define CCHR 4
5: #define CDOT 8
6: #define CCL 12
7: #define CDOL 20
8: #define CCEOF 22
9: #define CKET 24
10: #define CBACK 36
11:
12: #define STAR 01
13: #define RNGE 03
14:
15: #define NBRA 9
16:
17: #define PLACE(c) ep[c >> 3] |= bittab[c & 07]
18: #define ISTHERE(c) (ep[c >> 3] & bittab[c & 07])
19: #define ecmp(s1, s2, n) (!strncmp(s1, s2, n))
20:
21: static char *braslist[NBRA];
22: static char *braelist[NBRA];
23: static int ebra;
24: int sed, nbra;
25: char *loc1, *loc2, *locs;
26: static int nodelim;
27:
28: int circf;
29: static int low;
30: static int size;
31:
32: static char bittab[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
33:
34: char *
35: compile(instring, ep, endbuf, seof)
36: register char *ep;
37: char *instring, *endbuf;
38: {
39: INIT /* Dependent declarations and initializations */
40: register c;
41: register eof = seof;
42: char *lastep = instring;
43: int cclcnt;
44: char bracket[NBRA], *bracketp;
45: int closed;
46: int neg;
47: int lc;
48: int i, cflg;
49:
50: lastep = 0;
51: if((c = GETC()) == eof || c == '\n') {
52: if(c == '\n') {
53: UNGETC(c);
54: nodelim = 1;
55: }
56: if(*ep == 0 && !sed)
57: ERROR(41);
58: RETURN(ep);
59: }
60: bracketp = bracket;
61: circf = closed = nbra = ebra = 0;
62: if(c == '^')
63: circf++;
64: else
65: UNGETC(c);
66: while(1) {
67: if(ep >= endbuf)
68: ERROR(50);
69: c = GETC();
70: if(c != '*' && ((c != '\\') || (PEEKC() != '{')))
71: lastep = ep;
72: if(c == eof) {
73: *ep++ = CCEOF;
74: RETURN(ep);
75: }
76: switch(c) {
77:
78: case '.':
79: *ep++ = CDOT;
80: continue;
81:
82: case '\n':
83: if(!sed) {
84: UNGETC(c);
85: *ep++ = CCEOF;
86: nodelim = 1;
87: RETURN(ep);
88: }
89: else ERROR(36);
90: case '*':
91: if(lastep == 0 || *lastep == CBRA || *lastep == CKET)
92: goto defchar;
93: *lastep |= STAR;
94: continue;
95:
96: case '$':
97: if(PEEKC() != eof && PEEKC() != '\n')
98: goto defchar;
99: *ep++ = CDOL;
100: continue;
101:
102: case '[':
103: if(&ep[17] >= endbuf)
104: ERROR(50);
105:
106: *ep++ = CCL;
107: lc = 0;
108: for(i = 0; i < 16; i++)
109: ep[i] = 0;
110:
111: neg = 0;
112: if((c = GETC()) == '^') {
113: neg = 1;
114: c = GETC();
115: }
116:
117: do {
118: if(c == '\0' || c == '\n')
119: ERROR(49);
120: if(c == '-' && lc != 0) {
121: if((c = GETC()) == ']') {
122: PLACE('-');
123: break;
124: }
125: while(lc < c) {
126: PLACE(lc);
127: lc++;
128: }
129: }
130: lc = c;
131: PLACE(c);
132: } while((c = GETC()) != ']');
133: if(neg) {
134: for(cclcnt = 0; cclcnt < 16; cclcnt++)
135: ep[cclcnt] ^= -1;
136: ep[0] &= 0376;
137: }
138:
139: ep += 16;
140:
141: continue;
142:
143: case '\\':
144: switch(c = GETC()) {
145:
146: case '(':
147: if(nbra >= NBRA)
148: ERROR(43);
149: *bracketp++ = nbra;
150: *ep++ = CBRA;
151: *ep++ = nbra++;
152: continue;
153:
154: case ')':
155: if(bracketp <= bracket || ++ebra != nbra)
156: ERROR(42);
157: *ep++ = CKET;
158: *ep++ = *--bracketp;
159: closed++;
160: continue;
161:
162: case '{':
163: if(lastep == (char *) 0)
164: goto defchar;
165: *lastep |= RNGE;
166: cflg = 0;
167: nlim:
168: c = GETC();
169: i = 0;
170: do {
171: if('0' <= c && c <= '9')
172: i = 10 * i + c - '0';
173: else
174: ERROR(16);
175: } while(((c = GETC()) != '\\') && (c != ','));
176: if(i > 255)
177: ERROR(11);
178: *ep++ = i;
179: if(c == ',') {
180: if(cflg++)
181: ERROR(44);
182: if((c = GETC()) == '\\')
183: *ep++ = 255;
184: else {
185: UNGETC(c);
186: goto nlim;
187: /* get 2'nd number */
188: }
189: }
190: if(GETC() != '}')
191: ERROR(45);
192: if(!cflg) /* one number */
193: *ep++ = i;
194: else if((ep[-1] & 0377) < (ep[-2] & 0377))
195: ERROR(46);
196: continue;
197:
198: case '\n':
199: ERROR(36);
200:
201: case 'n':
202: c = '\n';
203: goto defchar;
204:
205: default:
206: if(c >= '1' && c <= '9') {
207: if((c -= '1') >= closed)
208: ERROR(25);
209: *ep++ = CBACK;
210: *ep++ = c;
211: continue;
212: }
213: }
214: /* Drop through to default to use \ to turn off special chars */
215:
216: defchar:
217: default:
218: lastep = ep;
219: *ep++ = CCHR;
220: *ep++ = c;
221: }
222: }
223: }
224:
225: step(p1, p2)
226: register char *p1, *p2;
227: {
228: register c;
229:
230: if(circf) {
231: loc1 = p1;
232: return(advance(p1, p2));
233: }
234: /* fast check for first character */
235: if(*p2 == CCHR) {
236: c = p2[1];
237: do {
238: if(*p1 != c)
239: continue;
240: if(advance(p1, p2)) {
241: loc1 = p1;
242: return(1);
243: }
244: } while(*p1++);
245: return(0);
246: }
247: /* regular algorithm */
248: do {
249: if(advance(p1, p2)) {
250: loc1 = p1;
251: return(1);
252: }
253: } while(*p1++);
254: return(0);
255: }
256:
257: advance(lp, ep)
258: register char *lp, *ep;
259: {
260: register char *curlp;
261: int c;
262: char *bbeg;
263: int ct;
264:
265: while(1) {
266: switch(*ep++) {
267:
268: case CCHR:
269: if(*ep++ == *lp++)
270: continue;
271: return(0);
272:
273: case CDOT:
274: if(*lp++)
275: continue;
276: return(0);
277:
278: case CDOL:
279: if(*lp == 0)
280: continue;
281: return(0);
282:
283: case CCEOF:
284: loc2 = lp;
285: return(1);
286:
287: case CCL:
288: c = *lp++ & 0177;
289: if(ISTHERE(c)) {
290: ep += 16;
291: continue;
292: }
293: return(0);
294: case CBRA:
295: braslist[*ep++] = lp;
296: continue;
297:
298: case CKET:
299: braelist[*ep++] = lp;
300: continue;
301:
302: case CCHR | RNGE:
303: c = *ep++;
304: getrnge(ep);
305: while(low--)
306: if(*lp++ != c)
307: return(0);
308: curlp = lp;
309: while(size--)
310: if(*lp++ != c)
311: break;
312: if(size < 0)
313: lp++;
314: ep += 2;
315: goto star;
316:
317: case CDOT | RNGE:
318: getrnge(ep);
319: while(low--)
320: if(*lp++ == '\0')
321: return(0);
322: curlp = lp;
323: while(size--)
324: if(*lp++ == '\0')
325: break;
326: if(size < 0)
327: lp++;
328: ep += 2;
329: goto star;
330:
331: case CCL | RNGE:
332: getrnge(ep + 16);
333: while(low--) {
334: c = *lp++ & 0177;
335: if(!ISTHERE(c))
336: return(0);
337: }
338: curlp = lp;
339: while(size--) {
340: c = *lp++ & 0177;
341: if(!ISTHERE(c))
342: break;
343: }
344: if(size < 0)
345: lp++;
346: ep += 18; /* 16 + 2 */
347: goto star;
348:
349: case CBACK:
350: bbeg = braslist[*ep];
351: ct = braelist[*ep++] - bbeg;
352:
353: if(ecmp(bbeg, lp, ct)) {
354: lp += ct;
355: continue;
356: }
357: return(0);
358:
359: case CBACK | STAR:
360: bbeg = braslist[*ep];
361: ct = braelist[*ep++] - bbeg;
362: curlp = lp;
363: while(ecmp(bbeg, lp, ct))
364: lp += ct;
365:
366: while(lp >= curlp) {
367: if(advance(lp, ep)) return(1);
368: lp -= ct;
369: }
370: return(0);
371:
372:
373: case CDOT | STAR:
374: curlp = lp;
375: while(*lp++);
376: goto star;
377:
378: case CCHR | STAR:
379: curlp = lp;
380: while(*lp++ == *ep);
381: ep++;
382: goto star;
383:
384: case CCL | STAR:
385: curlp = lp;
386: do {
387: c = *lp++ & 0177;
388: } while(ISTHERE(c));
389: ep += 16;
390: goto star;
391:
392: star:
393: do {
394: if(--lp == locs)
395: break;
396: if(advance(lp, ep))
397: return(1);
398: } while(lp > curlp);
399: return(0);
400:
401: }
402: }
403: }
404:
405: static
406: getrnge(str)
407: register unsigned char *str;
408: {
409: low = *str++ & 0377;
410: size = (*str == (unsigned char)255)? 20000: (*str &0377) - low;
411: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.