Subversion Repositories or1k

/*

 * Simple test program for regexp(3) stuff.  Knows about debugging hooks.

 *

 *      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: try re [string [output [-]]]

 * The re is compiled and dumped, regexeced against the string, the result

 * is applied to output using regsub().  The - triggers a running narrative

 * from regexec().  Dumping and narrative don't happen unless DEBUG.

 *

 * If there are no arguments, stdin is assumed to be a stream of lines with

 * five fields:  a r.e., a string to match it against, a result code, a

 * source string for regsub, and the proper result.  Result codes are 'c'

 * for compile failure, 'y' for match success, 'n' for match failure.

 * Field separator is tab.

 */

#include <stdio.h>

#include <regexp.h>

#ifdef ERRAVAIL

char *progname;

extern char *mkprogname();

#endif

#ifdef DEBUG

extern int regnarrate;

#endif

char buf[BUFSIZ];

int errreport = 0;               /* Report errors via errseen? */

char *errseen = NULL;           /* Error message. */

int status = 0;                  /* Exit status. */

/* ARGSUSED */

main(argc, argv)

int argc;

char *argv[];

{

        regexp *r;

        int i;

#ifdef ERRAVAIL

        progname = mkprogname(argv[0]);

#endif

        if (argc == 1) {

                multiple();

                exit(status);

        }

        r = regcomp(argv[1]);

        if (r == NULL)

                error("regcomp failure", "");

#ifdef DEBUG

        regdump(r);

        if (argc > 4)

                regnarrate++;

#endif

        if (argc > 2) {

                i = regexec(r, argv[2]);

                printf("%d", i);

                for (i = 1; i < NSUBEXP; i++)

                        if (r->startp[i] != NULL && r->endp[i] != NULL)

                                printf(" \\%d", i);

                printf("\n");

        }

        if (argc > 3) {

                regsub(r, argv[3], buf);

                printf("%s\n", buf);

        }

        exit(status);

}

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;

regexp badregexp;               /* Implicit init to 0. */

multiple()

{

        char rbuf[BUFSIZ];

        char *field[5];

        char *scan;

        int i;

        regexp *r;

        extern char *strchr();

        errreport = 1;

        lineno = 0;

        while (fgets(rbuf, sizeof(rbuf), stdin) != NULL) {

                rbuf[strlen(rbuf)-1] = '\0';    /* Dispense with \n. */

                lineno++;

                scan = rbuf;

                for (i = 0; i < 5; i++) {

                        field[i] = scan;

                        if (field[i] == NULL) {

                                complain("bad testfile format", "");

                                exit(1);

                        }

                        scan = strchr(scan, '\t');

                        if (scan != NULL)

                                *scan++ = '\0';

                }

                try(field);

        }

        /* And finish up with some internal testing... */

        lineno = 9990;

        errseen = NULL;

        if (regcomp((char *)NULL) != NULL || errseen == NULL)

                complain("regcomp(NULL) doesn't complain", "");

        lineno = 9991;

        errseen = NULL;

        if (regexec((regexp *)NULL, "foo") || errseen == NULL)

                complain("regexec(NULL, ...) doesn't complain", "");

        lineno = 9992;

        r = regcomp("foo");

        if (r == NULL) {

                complain("regcomp(\"foo\") fails", "");

                return;

        }

        lineno = 9993;

        errseen = NULL;

        if (regexec(r, (char *)NULL) || errseen == NULL)

                complain("regexec(..., NULL) doesn't complain", "");

        lineno = 9994;

        errseen = NULL;

        regsub((regexp *)NULL, "foo", rbuf);

        if (errseen == NULL)

                complain("regsub(NULL, ..., ...) doesn't complain", "");

        lineno = 9995;

        errseen = NULL;

        regsub(r, (char *)NULL, rbuf);

        if (errseen == NULL)

                complain("regsub(..., NULL, ...) doesn't complain", "");

        lineno = 9996;

        errseen = NULL;

        regsub(r, "foo", (char *)NULL);

        if (errseen == NULL)

                complain("regsub(..., ..., NULL) doesn't complain", "");

        lineno = 9997;

        errseen = NULL;

        if (regexec(&badregexp, "foo") || errseen == NULL)

                complain("regexec(nonsense, ...) doesn't complain", "");

        lineno = 9998;

        errseen = NULL;

        regsub(&badregexp, "foo", rbuf);

        if (errseen == NULL)

                complain("regsub(nonsense, ..., ...) doesn't complain", "");

}

try(fields)

char **fields;

{

        regexp *r;

        char dbuf[BUFSIZ];

        errseen = NULL;

        r = regcomp(fields[0]);

        if (r == NULL) {

                if (*fields[2] != 'c')

                        complain("regcomp failure in `%s'", fields[0]);

                return;

        }

        if (*fields[2] == 'c') {

                complain("unexpected regcomp success in `%s'", fields[0]);

                free((char *)r);

                return;

        }

        if (!regexec(r, fields[1])) {

                if (*fields[2] != 'n')

                        complain("regexec failure in `%s'", "");

                free((char *)r);

                return;

        }

        if (*fields[2] == 'n') {

                complain("unexpected regexec success", "");

                free((char *)r);

                return;

        }

        errseen = NULL;

        regsub(r, fields[3], dbuf);

        if (errseen != NULL) {

                complain("regsub complaint", "");

                free((char *)r);

                return;

        }

        if (strcmp(dbuf, fields[4]) != 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 : "");

        status = 1;

}