posix/tst-boost.c

   1 /* Regular expression tests.
   2    Copyright (C) 2003 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <sys/types.h>
  22 #include <mcheck.h>
  23 #include <regex.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 void
  29 frob_escapes (char *src, int pattern)
  30 {
  31   char *dst;
  32
  33   for (dst = src; *src != '\0'; dst++, src++)
  34     {
  35       if (*src == '\\')
  36         {
  37           switch (src[1])
  38             {
  39             case 't':
  40               src++;
  41               *dst = '\t';
  42               continue;
  43             case 'n':
  44               src++;
  45               *dst = '\n';
  46               continue;
  47             case 'r':
  48               src++;
  49               *dst = '\r';
  50               continue;
  51             case '\\':
  52             case '^':
  53             case '{':
  54             case '|':
  55             case '}':
  56               if (!pattern)
  57                 {
  58                   src++;
  59                   *dst = *src;
  60                   continue;
  61                 }
  62               break;
  63             }
  64         }
  65       if (src != dst)
  66         *dst = *src;
  67     }
  68   *dst = '\0';
  69 }
  70
  71 int
  72 main (int argc, char **argv)
  73 {
  74   int ret = 0, n;
  75   char *line = NULL;
  76   size_t line_len = 0;
  77   ssize_t len;
  78   FILE *f;
  79   char *pattern, *string;
  80   int flags = REG_EXTENDED;
  81   int eflags = 0;
  82   regex_t re;
  83   regmatch_t rm[20];
  84
  85   mtrace ();
  86
  87   if (argc < 2)
  88     {
  89       fprintf (stderr, "Missing test filename\n");
  90       return 1;
  91     }
  92
  93   f = fopen (argv[1], "r");
  94   if (f == NULL)
  95     {
  96       fprintf (stderr, "Couldn't open %s\n", argv[1]);
  97       return 1;
  98     }
  99
 100   while ((len = getline (&line, &line_len, f)) > 0)
 101     {
 102       char *p, *q;
 103       int i;
 104
 105       if (line[len - 1] == '\n')
 106         line[--len] = '\0';
 107
 108       puts (line);
 109
 110       if (line[0] == ';')
 111         continue;
 112
 113       if (line[0] == '\0')
 114         continue;
 115
 116       if (line[0] == '-')
 117         {
 118           if (strstr (line, "REG_BASIC"))
 119             flags = 0;
 120           else
 121             flags = REG_EXTENDED;
 122           if (strstr (line, "REG_ICASE"))
 123             flags |= REG_ICASE;
 124           if (strstr (line, "REG_NEWLINE"))
 125             flags |= REG_NEWLINE;
 126           eflags = 0;
 127           if (strstr (line, "REG_NOTBOL"))
 128             eflags |= REG_NOTBOL;
 129           if (strstr (line, "REG_NOTEOL"))
 130             eflags |= REG_NOTEOL;
 131           continue;
 132         }
 133
 134       pattern = line + strspn (line, " \t");
 135       if (*pattern == '\0')
 136         continue;
 137       p = pattern + strcspn (pattern, " \t");
 138       if (*p == '\0')
 139         continue;
 140       *p++ = '\0';
 141
 142       string = p + strspn (p, " \t");
 143       if (*string == '\0')
 144         continue;
 145       if (*string == '"')
 146         {
 147           string++;
 148           p = strchr (string, '"');
 149           if (p == NULL)
 150             continue;
 151           *p++ = '\0';
 152         }
 153       else
 154         {
 155           p = string + strcspn (string, " \t");
 156           if (*string == '!')
 157             string = NULL;
 158           else if (*p == '\0')
 159             continue;
 160           else
 161             *p++ = '\0';
 162         }
 163
 164       frob_escapes (pattern, 1);
 165       if (string != NULL)
 166         frob_escapes (string, 0);
 167
 168       n = regcomp (&re, pattern, flags);
 169       if (n != 0)
 170         {
 171           if (string != NULL)
 172             {
 173               char buf[500];
 174               regerror (n, &re, buf, sizeof (buf));
 175               printf ("FAIL regcomp unexpectedly failed: %s\n",
 176                       buf);
 177               ret = 1;
 178             }
 179           continue;
 180         }
 181       else if (string == NULL)
 182         {
 183           regfree (&re);
 184           puts ("FAIL regcomp unpexpectedly succeeded");
 185           ret = 1;
 186           continue;
 187         }
 188
 189       if (regexec (&re, string, 20, rm, eflags))
 190         {
 191           for (i = 0; i < 20; ++i)
 192             {
 193               rm[i].rm_so = -1;
 194               rm[i].rm_eo = -1;
 195             }
 196         }
 197
 198       regfree (&re);
 199
 200       for (i = 0; i < 20 && *p != '\0'; ++i)
 201         {
 202           int rm_so, rm_eo;
 203
 204           rm_so = strtol (p, &q, 10);
 205           if (p == q)
 206             break;
 207           p = q;
 208
 209           rm_eo = strtol (p, &q, 10);
 210           if (p == q)
 211             break;
 212           p = q;
 213
 214           if (rm[i].rm_so != rm_so || rm[i].rm_eo != rm_eo)
 215             {
 216               printf ("FAIL rm[%d] %d..%d != expected %d..%d\n",
 217                       i, rm[i].rm_so, rm[i].rm_eo, rm_so, rm_eo);
 218               ret = 1;
 219               break;
 220             }
 221         }
 222     }
 223
 224   free (line);
 225   fclose (f);
 226   return ret;
 227 }