Subversion Repositories or1k

/*

 * 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 : "");

}