![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to timer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / libc / gen / regexp|
Return to timer.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / libc / gen / regexp |
1.1 root 1: /*
2: * Simple timing program for regcomp().
3: *
4: * Copyright (c) 1986 by University of Toronto.
5: * Written by Henry Spencer. Not derived from licensed software.
6: *
7: * Permission is granted to anyone to use this software for any
8: * purpose on any computer system, and to redistribute it freely,
9: * subject to the following restrictions:
10: *
11: * 1. The author is not responsible for the consequences of use of
12: * this software, no matter how awful, even if they arise
13: * from defects in it.
14: *
15: * 2. The origin of this software must not be misrepresented, either
16: * by explicit claim or by omission.
17: *
18: * 3. Altered versions must be plainly marked as such, and must not
19: * be misrepresented as being the original software.
20: *
21: * Usage: timer ncomp nexec nsub
22: * or
23: * timer ncomp nexec nsub regexp string [ answer [ sub ] ]
24: *
25: * The second form is for timing repetitions of a single test case.
26: * The first form's test data is a compiled-in copy of the "tests" file.
27: * Ncomp, nexec, nsub are how many times to do each regcomp, regexec,
28: * and regsub. The way to time an operation individually is to do something
29: * like "timer 1 50 1".
30: */
31: #include <stdio.h>
32:
33: struct try {
34: char *re, *str, *ans, *src, *dst;
35: } tests[] = {
36: #include "timer.t.h"
37: { NULL, NULL, NULL, NULL, NULL }
38: };
39:
40: #include <regexp.h>
41:
42: int errreport = 0; /* Report errors via errseen? */
43: char *errseen = NULL; /* Error message. */
44:
45: char *progname;
46:
47: /* ARGSUSED */
48: main(argc, argv)
49: int argc;
50: char *argv[];
51: {
52: int ncomp, nexec, nsub;
53: struct try one;
54: char dummy[512];
55:
56: if (argc < 4) {
57: ncomp = 1;
58: nexec = 1;
59: nsub = 1;
60: } else {
61: ncomp = atoi(argv[1]);
62: nexec = atoi(argv[2]);
63: nsub = atoi(argv[3]);
64: }
65:
66: progname = argv[0];
67: if (argc > 5) {
68: one.re = argv[4];
69: one.str = argv[5];
70: if (argc > 6)
71: one.ans = argv[6];
72: else
73: one.ans = "y";
74: if (argc > 7) {
75: one.src = argv[7];
76: one.dst = "xxx";
77: } else {
78: one.src = "x";
79: one.dst = "x";
80: }
81: errreport = 1;
82: try(one, ncomp, nexec, nsub);
83: } else
84: multiple(ncomp, nexec, nsub);
85: exit(0);
86: }
87:
88: void
89: regerror(s)
90: char *s;
91: {
92: if (errreport)
93: errseen = s;
94: else
95: error(s, "");
96: }
97:
98: #ifndef ERRAVAIL
99: error(s1, s2)
100: char *s1;
101: char *s2;
102: {
103: fprintf(stderr, "regexp: ");
104: fprintf(stderr, s1, s2);
105: fprintf(stderr, "\n");
106: exit(1);
107: }
108: #endif
109:
110: int lineno = 0;
111:
112: multiple(ncomp, nexec, nsub)
113: int ncomp, nexec, nsub;
114: {
115: register int i;
116: extern char *strchr();
117:
118: errreport = 1;
119: for (i = 0; tests[i].re != NULL; i++) {
120: lineno++;
121: try(tests[i], ncomp, nexec, nsub);
122: }
123: }
124:
125: try(fields, ncomp, nexec, nsub)
126: struct try fields;
127: int ncomp, nexec, nsub;
128: {
129: regexp *r;
130: char dbuf[BUFSIZ];
131: register int i;
132:
133: errseen = NULL;
134: r = regcomp(fields.re);
135: if (r == NULL) {
136: if (*fields.ans != 'c')
137: complain("regcomp failure in `%s'", fields.re);
138: return;
139: }
140: if (*fields.ans == 'c') {
141: complain("unexpected regcomp success in `%s'", fields.re);
142: free((char *)r);
143: return;
144: }
145: for (i = ncomp-1; i > 0; i--) {
146: free((char *)r);
147: r = regcomp(fields.re);
148: }
149: if (!regexec(r, fields.str)) {
150: if (*fields.ans != 'n')
151: complain("regexec failure in `%s'", "");
152: free((char *)r);
153: return;
154: }
155: if (*fields.ans == 'n') {
156: complain("unexpected regexec success", "");
157: free((char *)r);
158: return;
159: }
160: for (i = nexec-1; i > 0; i--)
161: (void) regexec(r, fields.str);
162: errseen = NULL;
163: for (i = nsub; i > 0; i--)
164: regsub(r, fields.src, dbuf);
165: if (errseen != NULL) {
166: complain("regsub complaint", "");
167: free((char *)r);
168: return;
169: }
170: if (strcmp(dbuf, fields.dst) != 0)
171: complain("regsub result `%s' wrong", dbuf);
172: free((char *)r);
173: }
174:
175: complain(s1, s2)
176: char *s1;
177: char *s2;
178: {
179: fprintf(stderr, "try: %d: ", lineno);
180: fprintf(stderr, s1, s2);
181: fprintf(stderr, " (%s)\n", (errseen != NULL) ? errseen : "");
182: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.