![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / ereg / regex|
Return to main.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / ereg / regex |
1.1 misho 1: #include <stdio.h>
2: #include <string.h>
3: #include <sys/types.h>
4: #include <regex.h>
5: #include <assert.h>
6: #include <stdlib.h>
7:
8: #include "main.ih"
9:
10: char *progname;
11: int debug = 0;
12: int line = 0;
13: int status = 0;
14:
15: int copts = REG_EXTENDED;
16: int eopts = 0;
17: regoff_t startoff = 0;
18: regoff_t endoff = 0;
19:
20:
21: extern int split();
22: extern void regprint();
23:
24: /*
25: - main - do the simple case, hand off to regress() for regression
26: */
27: int main(argc, argv)
28: int argc;
29: char *argv[];
30: {
31: regex_t re;
32: # define NS 10
33: regmatch_t subs[NS];
34: char erbuf[100];
35: int err;
36: size_t len;
37: int c;
38: int errflg = 0;
39: register int i;
40: extern int optind;
41: extern char *optarg;
42:
43: progname = argv[0];
44:
45: while ((c = getopt(argc, argv, "c:e:S:E:x")) != EOF)
46: switch (c) {
47: case 'c': /* compile options */
48: copts = options('c', optarg);
49: break;
50: case 'e': /* execute options */
51: eopts = options('e', optarg);
52: break;
53: case 'S': /* start offset */
54: startoff = (regoff_t)atoi(optarg);
55: break;
56: case 'E': /* end offset */
57: endoff = (regoff_t)atoi(optarg);
58: break;
59: case 'x': /* Debugging. */
60: debug++;
61: break;
62: case '?':
63: default:
64: errflg++;
65: break;
66: }
67: if (errflg) {
68: fprintf(stderr, "usage: %s ", progname);
69: fprintf(stderr, "[-c copt][-C][-d] [re]\n");
70: exit(2);
71: }
72:
73: if (optind >= argc) {
74: regress(stdin);
75: exit(status);
76: }
77:
78: err = regcomp(&re, argv[optind++], copts);
79: if (err) {
80: len = regerror(err, &re, erbuf, sizeof(erbuf));
81: fprintf(stderr, "error %s, %d/%d `%s'\n",
82: eprint(err), len, sizeof(erbuf), erbuf);
83: exit(status);
84: }
85: regprint(&re, stdout);
86:
87: if (optind >= argc) {
88: regfree(&re);
89: exit(status);
90: }
91:
92: if (eopts®_STARTEND) {
93: subs[0].rm_so = startoff;
94: subs[0].rm_eo = strlen(argv[optind]) - endoff;
95: }
96: err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
97: if (err) {
98: len = regerror(err, &re, erbuf, sizeof(erbuf));
99: fprintf(stderr, "error %s, %d/%d `%s'\n",
100: eprint(err), len, sizeof(erbuf), erbuf);
101: exit(status);
102: }
103: if (!(copts®_NOSUB)) {
104: len = (int)(subs[0].rm_eo - subs[0].rm_so);
105: if (subs[0].rm_so != -1) {
106: if (len != 0)
107: printf("match `%.*s'\n", (int)len,
108: argv[optind] + subs[0].rm_so);
109: else
110: printf("match `'@%.1s\n",
111: argv[optind] + subs[0].rm_so);
112: }
113: for (i = 1; i < NS; i++)
114: if (subs[i].rm_so != -1)
115: printf("(%d) `%.*s'\n", i,
116: (int)(subs[i].rm_eo - subs[i].rm_so),
117: argv[optind] + subs[i].rm_so);
118: }
119: exit(status);
120: }
121:
122: /*
123: - regress - main loop of regression test
124: == void regress(FILE *in);
125: */
126: void
127: regress(in)
128: FILE *in;
129: {
130: char inbuf[1000];
131: # define MAXF 10
132: char *f[MAXF];
133: int nf;
134: int i;
135: char erbuf[100];
136: size_t ne;
137: char *badpat = "invalid regular expression";
138: # define SHORT 10
139: char *bpname = "REG_BADPAT";
140: regex_t re;
141:
142: while (fgets(inbuf, sizeof(inbuf), in) != NULL) {
143: line++;
144: if (inbuf[0] == '#' || inbuf[0] == '\n')
145: continue; /* NOTE CONTINUE */
146: inbuf[strlen(inbuf)-1] = '\0'; /* get rid of stupid \n */
147: if (debug)
148: fprintf(stdout, "%d:\n", line);
149: nf = split(inbuf, f, MAXF, "\t\t");
150: if (nf < 3) {
151: fprintf(stderr, "bad input, line %d\n", line);
152: exit(1);
153: }
154: for (i = 0; i < nf; i++)
155: if (strcmp(f[i], "\"\"") == 0)
156: f[i] = "";
157: if (nf <= 3)
158: f[3] = NULL;
159: if (nf <= 4)
160: f[4] = NULL;
161: try(f[0], f[1], f[2], f[3], f[4], options('c', f[1]));
162: if (opt('&', f[1])) /* try with either type of RE */
163: try(f[0], f[1], f[2], f[3], f[4],
164: options('c', f[1]) &~ REG_EXTENDED);
165: }
166:
167: ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
168: if (strcmp(erbuf, badpat) != 0 || ne != strlen(badpat)+1) {
169: fprintf(stderr, "end: regerror() test gave `%s' not `%s'\n",
170: erbuf, badpat);
171: status = 1;
172: }
173: ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, (size_t)SHORT);
174: if (strncmp(erbuf, badpat, SHORT-1) != 0 || erbuf[SHORT-1] != '\0' ||
175: ne != strlen(badpat)+1) {
176: fprintf(stderr, "end: regerror() short test gave `%s' not `%.*s'\n",
177: erbuf, SHORT-1, badpat);
178: status = 1;
179: }
180: ne = regerror(REG_ITOA|REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
181: if (strcmp(erbuf, bpname) != 0 || ne != strlen(bpname)+1) {
182: fprintf(stderr, "end: regerror() ITOA test gave `%s' not `%s'\n",
183: erbuf, bpname);
184: status = 1;
185: }
186: re.re_endp = bpname;
187: ne = regerror(REG_ATOI, &re, erbuf, sizeof(erbuf));
188: if (atoi(erbuf) != (int)REG_BADPAT) {
189: fprintf(stderr, "end: regerror() ATOI test gave `%s' not `%ld'\n",
190: erbuf, (long)REG_BADPAT);
191: status = 1;
192: } else if (ne != strlen(erbuf)+1) {
193: fprintf(stderr, "end: regerror() ATOI test len(`%s') = %ld\n",
194: erbuf, (long)REG_BADPAT);
195: status = 1;
196: }
197: }
198:
199: /*
200: - try - try it, and report on problems
201: == void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
202: */
203: void
204: try(f0, f1, f2, f3, f4, opts)
205: char *f0;
206: char *f1;
207: char *f2;
208: char *f3;
209: char *f4;
210: int opts; /* may not match f1 */
211: {
212: regex_t re;
213: # define NSUBS 10
214: regmatch_t subs[NSUBS];
215: # define NSHOULD 15
216: char *should[NSHOULD];
217: int nshould;
218: char erbuf[100];
219: int err;
220: int len;
221: char *type = (opts & REG_EXTENDED) ? "ERE" : "BRE";
222: register int i;
223: char *grump;
224: char f0copy[1000];
225: char f2copy[1000];
226:
227: strcpy(f0copy, f0);
228: re.re_endp = (opts®_PEND) ? f0copy + strlen(f0copy) : NULL;
229: fixstr(f0copy);
230: err = regcomp(&re, f0copy, opts);
231: if (err != 0 && (!opt('C', f1) || err != efind(f2))) {
232: /* unexpected error or wrong error */
233: len = regerror(err, &re, erbuf, sizeof(erbuf));
234: fprintf(stderr, "%d: %s error %s, %d/%d `%s'\n",
235: line, type, eprint(err), len,
236: sizeof(erbuf), erbuf);
237: status = 1;
238: } else if (err == 0 && opt('C', f1)) {
239: /* unexpected success */
240: fprintf(stderr, "%d: %s should have given REG_%s\n",
241: line, type, f2);
242: status = 1;
243: err = 1; /* so we won't try regexec */
244: }
245:
246: if (err != 0) {
247: regfree(&re);
248: return;
249: }
250:
251: strcpy(f2copy, f2);
252: fixstr(f2copy);
253:
254: if (options('e', f1)®_STARTEND) {
255: if (strchr(f2, '(') == NULL || strchr(f2, ')') == NULL)
256: fprintf(stderr, "%d: bad STARTEND syntax\n", line);
257: subs[0].rm_so = strchr(f2, '(') - f2 + 1;
258: subs[0].rm_eo = strchr(f2, ')') - f2;
259: }
260: err = regexec(&re, f2copy, NSUBS, subs, options('e', f1));
261:
262: if (err != 0 && (f3 != NULL || err != REG_NOMATCH)) {
263: /* unexpected error or wrong error */
264: len = regerror(err, &re, erbuf, sizeof(erbuf));
265: fprintf(stderr, "%d: %s exec error %s, %d/%d `%s'\n",
266: line, type, eprint(err), len,
267: sizeof(erbuf), erbuf);
268: status = 1;
269: } else if (err != 0) {
270: /* nothing more to check */
271: } else if (f3 == NULL) {
272: /* unexpected success */
273: fprintf(stderr, "%d: %s exec should have failed\n",
274: line, type);
275: status = 1;
276: err = 1; /* just on principle */
277: } else if (opts®_NOSUB) {
278: /* nothing more to check */
279: } else if ((grump = check(f2, subs[0], f3)) != NULL) {
280: fprintf(stderr, "%d: %s %s\n", line, type, grump);
281: status = 1;
282: err = 1;
283: }
284:
285: if (err != 0 || f4 == NULL) {
286: regfree(&re);
287: return;
288: }
289:
290: for (i = 1; i < NSHOULD; i++)
291: should[i] = NULL;
292: nshould = split(f4, should+1, NSHOULD-1, ",");
293: if (nshould == 0) {
294: nshould = 1;
295: should[1] = "";
296: }
297: for (i = 1; i < NSUBS; i++) {
298: grump = check(f2, subs[i], should[i]);
299: if (grump != NULL) {
300: fprintf(stderr, "%d: %s $%d %s\n", line,
301: type, i, grump);
302: status = 1;
303: err = 1;
304: }
305: }
306:
307: regfree(&re);
308: }
309:
310: /*
311: - options - pick options out of a regression-test string
312: == int options(int type, char *s);
313: */
314: int
315: options(type, s)
316: int type; /* 'c' compile, 'e' exec */
317: char *s;
318: {
319: register char *p;
320: register int o = (type == 'c') ? copts : eopts;
321: register char *legal = (type == 'c') ? "bisnmp" : "^$#tl";
322:
323: for (p = s; *p != '\0'; p++)
324: if (strchr(legal, *p) != NULL)
325: switch (*p) {
326: case 'b':
327: o &= ~REG_EXTENDED;
328: break;
329: case 'i':
330: o |= REG_ICASE;
331: break;
332: case 's':
333: o |= REG_NOSUB;
334: break;
335: case 'n':
336: o |= REG_NEWLINE;
337: break;
338: case 'm':
339: o &= ~REG_EXTENDED;
340: o |= REG_NOSPEC;
341: break;
342: case 'p':
343: o |= REG_PEND;
344: break;
345: case '^':
346: o |= REG_NOTBOL;
347: break;
348: case '$':
349: o |= REG_NOTEOL;
350: break;
351: case '#':
352: o |= REG_STARTEND;
353: break;
354: case 't': /* trace */
355: o |= REG_TRACE;
356: break;
357: case 'l': /* force long representation */
358: o |= REG_LARGE;
359: break;
360: case 'r': /* force backref use */
361: o |= REG_BACKR;
362: break;
363: }
364: return(o);
365: }
366:
367: /*
368: - opt - is a particular option in a regression string?
369: == int opt(int c, char *s);
370: */
371: int /* predicate */
372: opt(c, s)
373: int c;
374: char *s;
375: {
376: return(strchr(s, c) != NULL);
377: }
378:
379: /*
380: - fixstr - transform magic characters in strings
381: == void fixstr(register char *p);
382: */
383: void
384: fixstr(p)
385: register char *p;
386: {
387: if (p == NULL)
388: return;
389:
390: for (; *p != '\0'; p++)
391: if (*p == 'N')
392: *p = '\n';
393: else if (*p == 'T')
394: *p = '\t';
395: else if (*p == 'S')
396: *p = ' ';
397: else if (*p == 'Z')
398: *p = '\0';
399: }
400:
401: /*
402: - check - check a substring match
403: == char *check(char *str, regmatch_t sub, char *should);
404: */
405: char * /* NULL or complaint */
406: check(str, sub, should)
407: char *str;
408: regmatch_t sub;
409: char *should;
410: {
411: register int len;
412: register int shlen;
413: register char *p;
414: static char grump[500];
415: register char *at = NULL;
416:
417: if (should != NULL && strcmp(should, "-") == 0)
418: should = NULL;
419: if (should != NULL && should[0] == '@') {
420: at = should + 1;
421: should = "";
422: }
423:
424: /* check rm_so and rm_eo for consistency */
425: if (sub.rm_so > sub.rm_eo || (sub.rm_so == -1 && sub.rm_eo != -1) ||
426: (sub.rm_so != -1 && sub.rm_eo == -1) ||
427: (sub.rm_so != -1 && sub.rm_so < 0) ||
428: (sub.rm_eo != -1 && sub.rm_eo < 0) ) {
429: sprintf(grump, "start %ld end %ld", (long)sub.rm_so,
430: (long)sub.rm_eo);
431: return(grump);
432: }
433:
434: /* check for no match */
435: if (sub.rm_so == -1 && should == NULL)
436: return(NULL);
437: if (sub.rm_so == -1)
438: return("did not match");
439:
440: /* check for in range */
441: if (sub.rm_eo > strlen(str)) {
442: sprintf(grump, "start %ld end %ld, past end of string",
443: (long)sub.rm_so, (long)sub.rm_eo);
444: return(grump);
445: }
446:
447: len = (int)(sub.rm_eo - sub.rm_so);
448: shlen = (int)strlen(should);
449: p = str + sub.rm_so;
450:
451: /* check for not supposed to match */
452: if (should == NULL) {
453: sprintf(grump, "matched `%.*s'", len, p);
454: return(grump);
455: }
456:
457: /* check for wrong match */
458: if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
459: sprintf(grump, "matched `%.*s' instead", len, p);
460: return(grump);
461: }
462: if (shlen > 0)
463: return(NULL);
464:
465: /* check null match in right place */
466: if (at == NULL)
467: return(NULL);
468: shlen = strlen(at);
469: if (shlen == 0)
470: shlen = 1; /* force check for end-of-string */
471: if (strncmp(p, at, shlen) != 0) {
472: sprintf(grump, "matched null at `%.20s'", p);
473: return(grump);
474: }
475: return(NULL);
476: }
477:
478: /*
479: - eprint - convert error number to name
480: == static char *eprint(int err);
481: */
482: static char *
483: eprint(err)
484: int err;
485: {
486: static char epbuf[100];
487: size_t len;
488:
489: len = regerror(REG_ITOA|err, (regex_t *)NULL, epbuf, sizeof(epbuf));
490: assert(len <= sizeof(epbuf));
491: return(epbuf);
492: }
493:
494: /*
495: - efind - convert error name to number
496: == static int efind(char *name);
497: */
498: static int
499: efind(name)
500: char *name;
501: {
502: static char efbuf[100];
503: regex_t re;
504:
505: sprintf(efbuf, "REG_%s", name);
506: assert(strlen(efbuf) < sizeof(efbuf));
507: re.re_endp = efbuf;
508: (void) regerror(REG_ATOI, &re, efbuf, sizeof(efbuf));
509: return(atoi(efbuf));
510: }