Logo Search packages:      
Sourcecode: linux86 version File versions  Download package

try.c

/*
 * 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;
}

Generated by  Doxygen 1.6.0   Back to index