posix/tst-rxspencer.c

   1 /* Regular expression tests.
   2    Copyright (C) 2003-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <sys/types.h>
  20 #include <mcheck.h>
  21 #include <regex.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <locale.h>
  26 #include <getopt.h>
  27
  28 static void
  29 replace_special_chars (char *str)
  30 {
  31   for (; (str = strpbrk (str, "NTSZ")) != NULL; ++str)
  32     switch (*str)
  33       {
  34       case 'N': *str = '\n'; break;
  35       case 'T': *str = '\t'; break;
  36       case 'S': *str = ' '; break;
  37       case 'Z': *str = '\0'; break;
  38       }
  39 }
  40
  41 static void
  42 glibc_re_syntax (char *str)
  43 {
  44   char *p, *end = strchr (str, '\0') + 1;
  45
  46   /* Replace [[:<:]] with \< and [[:>:]] with \>.  */
  47   for (p = str; (p = strstr (p, "[[:")) != NULL; )
  48     if ((p[3] == '<' || p[3] == '>') && strncmp (p + 4, ":]]", 3) == 0)
  49       {
  50         p[0] = '\\';
  51         p[1] = p[3];
  52         memmove (p + 2, p + 7, end - p - 7);
  53         end -= 5;
  54         p += 2;
  55       }
  56     else
  57       p += 3;
  58 }
  59
  60 static char *
  61 mb_replace (char *dst, const char c)
  62 {
  63   switch (c)
  64     {
  65     /* Replace a with \'a and A with \'A.  */
  66     case 'a':
  67       *dst++ = '\xc3';
  68       *dst++ = '\xa1';
  69       break;
  70     case 'A':
  71       *dst++ = '\xc3';
  72       *dst++ = '\x81';
  73       break;
  74     /* Replace b with \v{c} and B with \v{C}.  */
  75     case 'b':
  76       *dst++ = '\xc4';
  77       *dst++ = '\x8d';
  78       break;
  79     case 'B':
  80       *dst++ = '\xc4';
  81       *dst++ = '\x8c';
  82       break;
  83     /* Replace c with \v{d} and C with \v{D}.  */
  84     case 'c':
  85       *dst++ = '\xc4';
  86       *dst++ = '\x8f';
  87       break;
  88     case 'C':
  89       *dst++ = '\xc4';
  90       *dst++ = '\x8e';
  91       break;
  92     /* Replace d with \'e and D with \'E.  */
  93     case 'd':
  94       *dst++ = '\xc3';
  95       *dst++ = '\xa9';
  96       break;
  97     case 'D':
  98       *dst++ = '\xc3';
  99       *dst++ = '\x89';
 100       break;
 101     }
 102   return dst;
 103 }
 104
 105 static char *
 106 mb_frob_string (const char *str, const char *letters)
 107 {
 108   char *ret, *dst;
 109   const char *src;
 110
 111   if (str == NULL)
 112     return NULL;
 113
 114   ret = malloc (2 * strlen (str) + 1);
 115   if (ret == NULL)
 116     return NULL;
 117
 118   for (src = str, dst = ret; *src; ++src)
 119     if (strchr (letters, *src))
 120       dst = mb_replace (dst, *src);
 121     else
 122       *dst++ = *src;
 123   *dst = '\0';
 124   return ret;
 125 }
 126
 127 /* Like mb_frob_string, but don't replace anything between
 128    [: and :], [. and .] or [= and =] or characters escaped
 129    with a backslash.  */
 130
 131 static char *
 132 mb_frob_pattern (const char *str, const char *letters)
 133 {
 134   char *ret, *dst;
 135   const char *src;
 136   int in_class = 0, escaped = 0;
 137
 138   if (str == NULL)
 139     return NULL;
 140
 141   ret = malloc (2 * strlen (str) + 1);
 142   if (ret == NULL)
 143     return NULL;
 144
 145   for (src = str, dst = ret; *src; ++src)
 146     if (*src == '\\')
 147       {
 148         escaped ^= 1;
 149         *dst++ = *src;
 150       }
 151     else if (escaped)
 152       {
 153         escaped = 0;
 154         *dst++ = *src;
 155         continue;
 156       }
 157     else if (!in_class && strchr (letters, *src))
 158       dst = mb_replace (dst, *src);
 159     else
 160       {
 161         if (!in_class && *src == '[' && strchr (":.=", src[1]))
 162           in_class = 1;
 163         else if (in_class && *src == ']' && strchr (":.=", src[-1]))
 164           in_class = 0;
 165         *dst++ = *src;
 166       }
 167   *dst = '\0';
 168   return ret;
 169 }
 170
 171 static int
 172 check_match (regmatch_t *rm, int idx, const char *string,
 173              const char *match, const char *fail)
 174 {
 175   if (match[0] == '-' && match[1] == '\0')
 176     {
 177       if (rm[idx].rm_so == -1 && rm[idx].rm_eo == -1)
 178         return 0;
 179       printf ("%s rm[%d] unexpectedly matched\n", fail, idx);
 180       return 1;
 181     }
 182
 183   if (rm[idx].rm_so == -1 || rm[idx].rm_eo == -1)
 184     {
 185       printf ("%s rm[%d] unexpectedly did not match\n", fail, idx);
 186       return 1;
 187     }
 188
 189   if (match[0] == '@')
 190     {
 191       if (rm[idx].rm_so != rm[idx].rm_eo)
 192         {
 193           printf ("%s rm[%d] not empty\n", fail, idx);
 194           return 1;
 195         }
 196
 197       if (strncmp (string + rm[idx].rm_so, match + 1, strlen (match + 1) ?: 1))
 198         {
 199           printf ("%s rm[%d] not matching %s\n", fail, idx, match);
 200           return 1;
 201         }
 202       return 0;
 203     }
 204
 205   if (rm[idx].rm_eo - rm[idx].rm_so != strlen (match)
 206       || strncmp (string + rm[idx].rm_so, match,
 207                   rm[idx].rm_eo - rm[idx].rm_so))
 208     {
 209       printf ("%s rm[%d] not matching %s\n", fail, idx, match);
 210       return 1;
 211     }
 212
 213   return 0;
 214 }
 215
 216 static int
 217 test (const char *pattern, int cflags, const char *string, int eflags,
 218       char *expect, char *matches, const char *fail)
 219 {
 220   regex_t re;
 221   regmatch_t rm[10];
 222   int n, ret = 0;
 223
 224   n = regcomp (&re, pattern, cflags);
 225   if (n != 0)
 226     {
 227       char buf[500];
 228       if (eflags == -1)
 229         {
 230           static struct { reg_errcode_t code; const char *name; } codes []
 231 #define C(x) { REG_##x, #x }
 232             = { C(NOERROR), C(NOMATCH), C(BADPAT), C(ECOLLATE),
 233                 C(ECTYPE), C(EESCAPE), C(ESUBREG), C(EBRACK),
 234                 C(EPAREN), C(EBRACE), C(BADBR), C(ERANGE),
 235                 C(ESPACE), C(BADRPT) };
 236
 237           for (int i = 0; i < sizeof (codes) / sizeof (codes[0]); ++i)
 238             if (n == codes[i].code)
 239               {
 240                 if (strcmp (string, codes[i].name))
 241                   {
 242                     printf ("%s regcomp returned REG_%s (expected REG_%s)\n",
 243                             fail, codes[i].name, string);
 244                     return 1;
 245                   }
 246                 return 0;
 247               }
 248
 249           printf ("%s regcomp return value REG_%d\n", fail, n);
 250           return 1;
 251         }
 252
 253       regerror (n, &re, buf, sizeof (buf));
 254       printf ("%s regcomp failed: %s\n", fail, buf);
 255       return 1;
 256     }
 257
 258   if (eflags == -1)
 259     {
 260       regfree (&re);
 261
 262       /* The test case file assumes something only guaranteed by the
 263          rxspencer regex implementation.  Namely that for empty
 264          expressions regcomp() return REG_EMPTY.  This is not the case
 265          for us and so we ignore this error.  */
 266       if (strcmp (string, "EMPTY") == 0)
 267         return 0;
 268
 269       printf ("%s regcomp unexpectedly succeeded\n", fail);
 270       return 1;
 271     }
 272
 273   if (regexec (&re, string, 10, rm, eflags))
 274     {
 275       regfree (&re);
 276       if (expect == NULL)
 277         return 0;
 278       printf ("%s regexec failed\n", fail);
 279       return 1;
 280     }
 281
 282   regfree (&re);
 283
 284   if (expect == NULL)
 285     {
 286       printf ("%s regexec unexpectedly succeeded\n", fail);
 287       return 1;
 288     }
 289
 290   if (cflags & REG_NOSUB)
 291     return 0;
 292
 293   ret = check_match (rm, 0, string, expect, fail);
 294   if (matches == NULL)
 295     return ret;
 296
 297   for (n = 1; ret == 0 && n < 10; ++n)
 298     {
 299       char *p = NULL;
 300
 301       if (matches)
 302         {
 303           p = strchr (matches, ',');
 304           if (p != NULL)
 305             *p = '\0';
 306         }
 307       ret = check_match (rm, n, string, matches ?: "-", fail);
 308       if (p)
 309         {
 310           *p = ',';
 311           matches = p + 1;
 312         }
 313       else
 314         matches = NULL;
 315     }
 316
 317   return ret;
 318 }
 319
 320 static int
 321 mb_test (const char *pattern, int cflags, const char *string, int eflags,
 322          char *expect, const char *matches, const char *letters,
 323          const char *fail)
 324 {
 325   char *pattern_mb = mb_frob_pattern (pattern, letters);
 326   const char *string_mb
 327     = eflags == -1 ? string : mb_frob_string (string, letters);
 328   char *expect_mb = mb_frob_string (expect, letters);
 329   char *matches_mb = mb_frob_string (matches, letters);
 330   int ret = 0;
 331
 332   if (!pattern_mb || !string_mb
 333       || (expect && !expect_mb) || (matches && !matches_mb))
 334     {
 335       printf ("%s %m", fail);
 336       ret = 1;
 337     }
 338   else
 339     ret = test (pattern_mb, cflags, string_mb, eflags, expect_mb,
 340                 matches_mb, fail);
 341
 342   free (matches_mb);
 343   free (expect_mb);
 344   if (string_mb != string)
 345     free ((char *) string_mb);
 346   free (pattern_mb);
 347   return ret;
 348 }
 349
 350 static int
 351 mb_tests (const char *pattern, int cflags, const char *string, int eflags,
 352           char *expect, const char *matches)
 353 {
 354   int ret = 0;
 355   int i;
 356   char letters[9], fail[20];
 357
 358   /* The tests aren't supposed to work with xdigit, since a-dA-D are
 359      hex digits while \'a \'A \v{c}\v{C}\v{d}\v{D}\'e \'E are not.  */
 360   if (strstr (pattern, "[:xdigit:]"))
 361     return 0;
 362
 363   /* XXX: regex ATM handles only single byte equivalence classes.  */
 364   if (strstr (pattern, "[[=b=]]"))
 365     return 0;
 366
 367   for (i = 1; i < 16; ++i)
 368     {
 369       char *p = letters;
 370       if (i & 1)
 371         {
 372           if (!strchr (pattern, 'a') && !strchr (string, 'a')
 373               && !strchr (pattern, 'A') && !strchr (string, 'A'))
 374             continue;
 375           *p++ = 'a', *p++ = 'A';
 376         }
 377       if (i & 2)
 378         {
 379           if (!strchr (pattern, 'b') && !strchr (string, 'b')
 380               && !strchr (pattern, 'B') && !strchr (string, 'B'))
 381             continue;
 382           *p++ = 'b', *p++ = 'B';
 383         }
 384       if (i & 4)
 385         {
 386           if (!strchr (pattern, 'c') && !strchr (string, 'c')
 387               && !strchr (pattern, 'C') && !strchr (string, 'C'))
 388             continue;
 389           *p++ = 'c', *p++ = 'C';
 390         }
 391       if (i & 8)
 392         {
 393           if (!strchr (pattern, 'd') && !strchr (string, 'd')
 394               && !strchr (pattern, 'D') && !strchr (string, 'D'))
 395             continue;
 396           *p++ = 'd', *p++ = 'D';
 397         }
 398       *p++ = '\0';
 399       sprintf (fail, "UTF-8 %s FAIL", letters);
 400       ret |= mb_test (pattern, cflags, string, eflags, expect, matches,
 401                       letters, fail);
 402     }
 403   return ret;
 404 }
 405
 406 int
 407 main (int argc, char **argv)
 408 {
 409   int ret = 0;
 410   char *line = NULL;
 411   size_t line_len = 0;
 412   ssize_t len;
 413   FILE *f;
 414   static int test_utf8 = 0;
 415   static const struct option options[] =
 416     {
 417       {"utf8",  no_argument,    &test_utf8,     1},
 418       {NULL,    0,              NULL,           0 }
 419     };
 420
 421   mtrace ();
 422
 423   while (getopt_long (argc, argv, "", options, NULL) >= 0);
 424
 425   if (optind + 1 != argc)
 426     {
 427       fprintf (stderr, "Missing test filename\n");
 428       return 1;
 429     }
 430
 431   f = fopen (argv[optind], "r");
 432   if (f == NULL)
 433     {
 434       fprintf (stderr, "Couldn't open %s\n", argv[optind]);
 435       return 1;
 436     }
 437
 438   while ((len = getline (&line, &line_len, f)) > 0)
 439     {
 440       char *pattern, *flagstr, *string, *expect, *matches, *p;
 441       int cflags = REG_EXTENDED, eflags = 0, try_bre_ere = 0;
 442
 443       if (line[len - 1] == '\n')
 444         line[len - 1] = '\0';
 445
 446       /* Skip comments and empty lines.  */
 447       if (*line == '#' || *line == '\0')
 448         continue;
 449
 450       puts (line);
 451       fflush (stdout);
 452
 453       pattern = strtok (line, "\t");
 454       if (pattern == NULL)
 455         continue;
 456
 457       if (strcmp (pattern, "\"\"") == 0)
 458         pattern += 2;
 459
 460       flagstr = strtok (NULL, "\t");
 461       if (flagstr == NULL)
 462         continue;
 463
 464       string = strtok (NULL, "\t");
 465       if (string == NULL)
 466         continue;
 467
 468       if (strcmp (string, "\"\"") == 0)
 469         string += 2;
 470
 471       for (p = flagstr; *p; ++p)
 472         switch (*p)
 473           {
 474           case '-':
 475             break;
 476           case 'b':
 477             cflags &= ~REG_EXTENDED;
 478             break;
 479           case '&':
 480             try_bre_ere = 1;
 481             break;
 482           case 'C':
 483             eflags = -1;
 484             break;
 485           case 'i':
 486             cflags |= REG_ICASE;
 487             break;
 488           case 's':
 489             cflags |= REG_NOSUB;
 490             break;
 491           case 'n':
 492             cflags |= REG_NEWLINE;
 493             break;
 494           case '^':
 495             eflags |= REG_NOTBOL;
 496             break;
 497           case '$':
 498             eflags |= REG_NOTEOL;
 499             break;
 500           case 'm':
 501           case 'p':
 502           case '#':
 503             /* Not supported.  */
 504             flagstr = NULL;
 505             break;
 506           }
 507
 508       if (flagstr == NULL)
 509         continue;
 510
 511       replace_special_chars (pattern);
 512       glibc_re_syntax (pattern);
 513       if (eflags != -1)
 514         replace_special_chars (string);
 515
 516       expect = strtok (NULL, "\t");
 517       matches = NULL;
 518       if (expect != NULL)
 519         {
 520           replace_special_chars (expect);
 521           matches = strtok (NULL, "\t");
 522           if (matches != NULL)
 523             replace_special_chars (matches);
 524         }
 525
 526       if (setlocale (LC_ALL, "C") == NULL)
 527         {
 528           puts ("setlocale C failed");
 529           ret = 1;
 530         }
 531       if (test (pattern, cflags, string, eflags, expect, matches, "FAIL")
 532           || (try_bre_ere
 533               && test (pattern, cflags & ~REG_EXTENDED, string, eflags,
 534                        expect, matches, "FAIL")))
 535         ret = 1;
 536       else if (test_utf8)
 537         {
 538           if (setlocale (LC_ALL, "cs_CZ.UTF-8") == NULL)
 539             {
 540               puts ("setlocale cs_CZ.UTF-8 failed");
 541               ret = 1;
 542             }
 543           else if (test (pattern, cflags, string, eflags, expect, matches,
 544                          "UTF-8 FAIL")
 545                    || (try_bre_ere
 546                        && test (pattern, cflags & ~REG_EXTENDED, string,
 547                                 eflags, expect, matches, "UTF-8 FAIL")))
 548             ret = 1;
 549           else if (mb_tests (pattern, cflags, string, eflags, expect, matches)
 550                    || (try_bre_ere
 551                        && mb_tests (pattern, cflags & ~REG_EXTENDED, string,
 552                                     eflags, expect, matches)))
 553             ret = 1;
 554         }
 555     }
 556
 557   free (line);
 558   fclose (f);
 559   return ret;
 560 }