Return to timer.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / lib / libc / gen / regexp

Annotation of 43BSDTahoe/lib/libc/gen/regexp/timer.c, revision 1.1

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.