BSD 4_3_Tahoe development

Work on file usr/src/lib/libc/gen/regexp/timer.c

Synthesized-from: CSRG/cd2/4.3tahoe

diff --git a/usr/src/lib/libc/gen/regexp/timer.c b/usr/src/lib/libc/gen/regexp/timer.c
new file mode 100644 (file)
index 0000000..2d84a12
--- /dev/null
+++ b/usr/src/lib/libc/gen/regexp/timer.c
@@ -0,0 +1,182 @@
+/*
+ * Simple timing program for regcomp().
+ *
+ *     Copyright (c) 1986 by University of Toronto.
+ *     Written by Henry Spencer.  Not derived from licensed software.
+ *
+ *     Permission is granted to anyone to use this software for any
+ *     purpose on any computer system, and to redistribute it freely,
+ *     subject to the following restrictions:
+ *
+ *     1. The author is not responsible for the consequences of use of
+ *             this software, no matter how awful, even if they arise
+ *             from defects in it.
+ *
+ *     2. The origin of this software must not be misrepresented, either
+ *             by explicit claim or by omission.
+ *
+ *     3. Altered versions must be plainly marked as such, and must not
+ *             be misrepresented as being the original software.
+ *
+ * Usage: timer ncomp nexec nsub
+ *     or
+ *     timer ncomp nexec nsub regexp string [ answer [ sub ] ]
+ *
+ * The second form is for timing repetitions of a single test case.
+ * The first form's test data is a compiled-in copy of the "tests" file.
+ * Ncomp, nexec, nsub are how many times to do each regcomp, regexec,
+ * and regsub.  The way to time an operation individually is to do something
+ * like "timer 1 50 1".
+ */
+#include <stdio.h>
+
+struct try {
+       char *re, *str, *ans, *src, *dst;
+} tests[] = {
+#include "timer.t.h"
+{ NULL, NULL, NULL, NULL, NULL }
+};
+
+#include <regexp.h>
+
+int errreport = 0;             /* Report errors via errseen? */
+char *errseen = NULL;          /* Error message. */
+
+char *progname;
+
+/* ARGSUSED */
+main(argc, argv)
+int argc;
+char *argv[];
+{
+       int ncomp, nexec, nsub;
+       struct try one;
+       char dummy[512];
+
+       if (argc < 4) {
+               ncomp = 1;
+               nexec = 1;
+               nsub = 1;
+       } else {
+               ncomp = atoi(argv[1]);
+               nexec = atoi(argv[2]);
+               nsub = atoi(argv[3]);
+       }
+       
+       progname = argv[0];
+       if (argc > 5) {
+               one.re = argv[4];
+               one.str = argv[5];
+               if (argc > 6)
+                       one.ans = argv[6];
+               else
+                       one.ans = "y";
+               if (argc > 7) { 
+                       one.src = argv[7];
+                       one.dst = "xxx";
+               } else {
+                       one.src = "x";
+                       one.dst = "x";
+               }
+               errreport = 1;
+               try(one, ncomp, nexec, nsub);
+       } else
+               multiple(ncomp, nexec, nsub);
+       exit(0);
+}
+
+void
+regerror(s)
+char *s;
+{
+       if (errreport)
+               errseen = s;
+       else
+               error(s, "");
+}
+
+#ifndef ERRAVAIL
+error(s1, s2)
+char *s1;
+char *s2;
+{
+       fprintf(stderr, "regexp: ");
+       fprintf(stderr, s1, s2);
+       fprintf(stderr, "\n");
+       exit(1);
+}
+#endif
+
+int lineno = 0;
+
+multiple(ncomp, nexec, nsub)
+int ncomp, nexec, nsub;
+{
+       register int i;
+       extern char *strchr();
+
+       errreport = 1;
+       for (i = 0; tests[i].re != NULL; i++) {
+               lineno++;
+               try(tests[i], ncomp, nexec, nsub);
+       }
+}
+
+try(fields, ncomp, nexec, nsub)
+struct try fields;
+int ncomp, nexec, nsub;
+{
+       regexp *r;
+       char dbuf[BUFSIZ];
+       register int i;
+
+       errseen = NULL;
+       r = regcomp(fields.re);
+       if (r == NULL) {
+               if (*fields.ans != 'c')
+                       complain("regcomp failure in `%s'", fields.re);
+               return;
+       }
+       if (*fields.ans == 'c') {
+               complain("unexpected regcomp success in `%s'", fields.re);
+               free((char *)r);
+               return;
+       }
+       for (i = ncomp-1; i > 0; i--) {
+               free((char *)r);
+               r = regcomp(fields.re);
+       }
+       if (!regexec(r, fields.str)) {
+               if (*fields.ans != 'n')
+                       complain("regexec failure in `%s'", "");
+               free((char *)r);
+               return;
+       }
+       if (*fields.ans == 'n') {
+               complain("unexpected regexec success", "");
+               free((char *)r);
+               return;
+       }
+       for (i = nexec-1; i > 0; i--)
+               (void) regexec(r, fields.str);
+       errseen = NULL;
+       for (i = nsub; i > 0; i--)
+               regsub(r, fields.src, dbuf);
+       if (errseen != NULL) {  
+               complain("regsub complaint", "");
+               free((char *)r);
+               return;
+       }
+       if (strcmp(dbuf, fields.dst) != 0)
+               complain("regsub result `%s' wrong", dbuf);
+       free((char *)r);
+}
+
+complain(s1, s2)
+char *s1;
+char *s2;
+{
+       fprintf(stderr, "try: %d: ", lineno);
+       fprintf(stderr, s1, s2);
+       fprintf(stderr, " (%s)\n", (errseen != NULL) ? errseen : "");
+}