Return to try.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * Simple test program for regexp(3) stuff.  Knows about debugging hooks.
        !             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: try re [string [output [-]]]
        !            22:  * The re is compiled and dumped, regexeced against the string, the result
        !            23:  * is applied to output using regsub().  The - triggers a running narrative
        !            24:  * from regexec().  Dumping and narrative don't happen unless DEBUG.
        !            25:  *
        !            26:  * If there are no arguments, stdin is assumed to be a stream of lines with
        !            27:  * five fields:  a r.e., a string to match it against, a result code, a
        !            28:  * source string for regsub, and the proper result.  Result codes are 'c'
        !            29:  * for compile failure, 'y' for match success, 'n' for match failure.
        !            30:  * Field separator is tab.
        !            31:  */
        !            32: #include <stdio.h>
        !            33: #include <regexp.h>
        !            34: 
        !            35: #ifdef ERRAVAIL
        !            36: char *progname;
        !            37: extern char *mkprogname();
        !            38: #endif
        !            39: 
        !            40: #ifdef DEBUG
        !            41: extern int regnarrate;
        !            42: #endif
        !            43: 
        !            44: char buf[BUFSIZ];
        !            45: 
        !            46: int errreport = 0;             /* Report errors via errseen? */
        !            47: char *errseen = NULL;          /* Error message. */
        !            48: int status = 0;                        /* Exit status. */
        !            49: 
        !            50: /* ARGSUSED */
        !            51: main(argc, argv)
        !            52: int argc;
        !            53: char *argv[];
        !            54: {
        !            55:        regexp *r;
        !            56:        int i;
        !            57: 
        !            58: #ifdef ERRAVAIL
        !            59:        progname = mkprogname(argv[0]);
        !            60: #endif
        !            61: 
        !            62:        if (argc == 1) {
        !            63:                multiple();
        !            64:                exit(status);
        !            65:        }
        !            66: 
        !            67:        r = regcomp(argv[1]);
        !            68:        if (r == NULL)
        !            69:                error("regcomp failure", "");
        !            70: #ifdef DEBUG
        !            71:        regdump(r);
        !            72:        if (argc > 4)
        !            73:                regnarrate++;
        !            74: #endif
        !            75:        if (argc > 2) {
        !            76:                i = regexec(r, argv[2]);
        !            77:                printf("%d", i);
        !            78:                for (i = 1; i < NSUBEXP; i++)
        !            79:                        if (r->startp[i] != NULL && r->endp[i] != NULL)
        !            80:                                printf(" \\%d", i);
        !            81:                printf("\n");
        !            82:        }
        !            83:        if (argc > 3) {
        !            84:                regsub(r, argv[3], buf);
        !            85:                printf("%s\n", buf);
        !            86:        }
        !            87:        exit(status);
        !            88: }
        !            89: 
        !            90: void
        !            91: regerror(s)
        !            92: char *s;
        !            93: {
        !            94:        if (errreport)
        !            95:                errseen = s;
        !            96:        else
        !            97:                error(s, "");
        !            98: }
        !            99: 
        !           100: #ifndef ERRAVAIL
        !           101: error(s1, s2)
        !           102: char *s1;
        !           103: char *s2;
        !           104: {
        !           105:        fprintf(stderr, "regexp: ");
        !           106:        fprintf(stderr, s1, s2);
        !           107:        fprintf(stderr, "\n");
        !           108:        exit(1);
        !           109: }
        !           110: #endif
        !           111: 
        !           112: int lineno;
        !           113: 
        !           114: regexp badregexp;              /* Implicit init to 0. */
        !           115: 
        !           116: multiple()
        !           117: {
        !           118:        char rbuf[BUFSIZ];
        !           119:        char *field[5];
        !           120:        char *scan;
        !           121:        int i;
        !           122:        regexp *r;
        !           123:        extern char *strchr();
        !           124: 
        !           125:        errreport = 1;
        !           126:        lineno = 0;
        !           127:        while (fgets(rbuf, sizeof(rbuf), stdin) != NULL) {
        !           128:                rbuf[strlen(rbuf)-1] = '\0';    /* Dispense with \n. */
        !           129:                lineno++;
        !           130:                scan = rbuf;
        !           131:                for (i = 0; i < 5; i++) {
        !           132:                        field[i] = scan;
        !           133:                        if (field[i] == NULL) {
        !           134:                                complain("bad testfile format", "");
        !           135:                                exit(1);
        !           136:                        }
        !           137:                        scan = strchr(scan, '\t');
        !           138:                        if (scan != NULL)
        !           139:                                *scan++ = '\0';
        !           140:                }
        !           141:                try(field);
        !           142:        }
        !           143: 
        !           144:        /* And finish up with some internal testing... */
        !           145:        lineno = 9990;
        !           146:        errseen = NULL;
        !           147:        if (regcomp((char *)NULL) != NULL || errseen == NULL)
        !           148:                complain("regcomp(NULL) doesn't complain", "");
        !           149:        lineno = 9991;
        !           150:        errseen = NULL;
        !           151:        if (regexec((regexp *)NULL, "foo") || errseen == NULL)
        !           152:                complain("regexec(NULL, ...) doesn't complain", "");
        !           153:        lineno = 9992;
        !           154:        r = regcomp("foo");
        !           155:        if (r == NULL) {
        !           156:                complain("regcomp(\"foo\") fails", "");
        !           157:                return;
        !           158:        }
        !           159:        lineno = 9993;
        !           160:        errseen = NULL;
        !           161:        if (regexec(r, (char *)NULL) || errseen == NULL)
        !           162:                complain("regexec(..., NULL) doesn't complain", "");
        !           163:        lineno = 9994;
        !           164:        errseen = NULL;
        !           165:        regsub((regexp *)NULL, "foo", rbuf);
        !           166:        if (errseen == NULL)
        !           167:                complain("regsub(NULL, ..., ...) doesn't complain", "");
        !           168:        lineno = 9995;
        !           169:        errseen = NULL;
        !           170:        regsub(r, (char *)NULL, rbuf);
        !           171:        if (errseen == NULL)
        !           172:                complain("regsub(..., NULL, ...) doesn't complain", "");
        !           173:        lineno = 9996;
        !           174:        errseen = NULL;
        !           175:        regsub(r, "foo", (char *)NULL);
        !           176:        if (errseen == NULL)
        !           177:                complain("regsub(..., ..., NULL) doesn't complain", "");
        !           178:        lineno = 9997;
        !           179:        errseen = NULL;
        !           180:        if (regexec(&badregexp, "foo") || errseen == NULL)
        !           181:                complain("regexec(nonsense, ...) doesn't complain", "");
        !           182:        lineno = 9998;
        !           183:        errseen = NULL;
        !           184:        regsub(&badregexp, "foo", rbuf);
        !           185:        if (errseen == NULL)
        !           186:                complain("regsub(nonsense, ..., ...) doesn't complain", "");
        !           187: }
        !           188: 
        !           189: try(fields)
        !           190: char **fields;
        !           191: {
        !           192:        regexp *r;
        !           193:        char dbuf[BUFSIZ];
        !           194: 
        !           195:        errseen = NULL;
        !           196:        r = regcomp(fields[0]);
        !           197:        if (r == NULL) {
        !           198:                if (*fields[2] != 'c')
        !           199:                        complain("regcomp failure in `%s'", fields[0]);
        !           200:                return;
        !           201:        }
        !           202:        if (*fields[2] == 'c') {
        !           203:                complain("unexpected regcomp success in `%s'", fields[0]);
        !           204:                free((char *)r);
        !           205:                return;
        !           206:        }
        !           207:        if (!regexec(r, fields[1])) {
        !           208:                if (*fields[2] != 'n')
        !           209:                        complain("regexec failure in `%s'", "");
        !           210:                free((char *)r);
        !           211:                return;
        !           212:        }
        !           213:        if (*fields[2] == 'n') {
        !           214:                complain("unexpected regexec success", "");
        !           215:                free((char *)r);
        !           216:                return;
        !           217:        }
        !           218:        errseen = NULL;
        !           219:        regsub(r, fields[3], dbuf);
        !           220:        if (errseen != NULL) {
        !           221:                complain("regsub complaint", "");
        !           222:                free((char *)r);
        !           223:                return;
        !           224:        }
        !           225:        if (strcmp(dbuf, fields[4]) != 0)
        !           226:                complain("regsub result `%s' wrong", dbuf);
        !           227:        free((char *)r);
        !           228: }
        !           229: 
        !           230: complain(s1, s2)
        !           231: char *s1;
        !           232: char *s2;
        !           233: {
        !           234:        fprintf(stderr, "try: %d: ", lineno);
        !           235:        fprintf(stderr, s1, s2);
        !           236:        fprintf(stderr, " (%s)\n", (errseen != NULL) ? errseen : "");
        !           237:        status = 1;
        !           238: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.