source: vendor/glibc-tests/glibc/posix/tst-boost.c

/* Regular expression tests.
   Copyright (C) 2003 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include <sys/types.h>
#include <mcheck.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void
frob_escapes (char *src, int pattern)
{
  char *dst;

  for (dst = src; *src != '\0'; dst++, src++)
    {
      if (*src == '\\')
        {
          switch (src[1])
            {
            case 't':
              src++;
              *dst = '\t';
              continue;
            case 'n':
              src++;
              *dst = '\n';
              continue;
            case 'r':
              src++;
              *dst = '\r';
              continue;
            case '\\':
            case '^':
            case '{':
            case '|':
            case '}':
              if (!pattern)
                {
                  src++;
                  *dst = *src;
                  continue;
                }
              break;
            }
        }
      if (src != dst)
        *dst = *src;
    }
  *dst = '\0';
}

int
main (int argc, char **argv)
{
  int ret = 0, n;
  char *line = NULL;
  size_t line_len = 0;
  ssize_t len;
  FILE *f;
  char *pattern, *string;
  int flags = REG_EXTENDED;
  int eflags = 0;
  regex_t re;
  regmatch_t rm[20];

  mtrace ();

  if (argc < 2)
    {
      fprintf (stderr, "Missing test filename\n");
      return 1;
    }

  f = fopen (argv[1], "r");
  if (f == NULL)
    {
      fprintf (stderr, "Couldn't open %s\n", argv[1]);
      return 1;
    }

  while ((len = getline (&line, &line_len, f)) > 0)
    {
      char *p, *q;
      int i;

      if (line[len - 1] == '\n')
        line[--len] = '\0';

      puts (line);

      if (line[0] == ';')
        continue;

      if (line[0] == '\0')
        continue;

      if (line[0] == '-')
        {
          if (strstr (line, "REG_BASIC"))
            flags = 0;
          else
            flags = REG_EXTENDED;
          if (strstr (line, "REG_ICASE"))
            flags |= REG_ICASE;
          if (strstr (line, "REG_NEWLINE"))
            flags |= REG_NEWLINE;
          eflags = 0;
          if (strstr (line, "REG_NOTBOL"))
            eflags |= REG_NOTBOL;
          if (strstr (line, "REG_NOTEOL"))
            eflags |= REG_NOTEOL;
          continue;
        }

      pattern = line + strspn (line, " \t");
      if (*pattern == '\0')
        continue;
      p = pattern + strcspn (pattern, " \t");
      if (*p == '\0')
        continue;
      *p++ = '\0';

      string = p + strspn (p, " \t");
      if (*string == '\0')
        continue;
      if (*string == '"')
        {
          string++;
          p = strchr (string, '"');
          if (p == NULL)
            continue;
          *p++ = '\0';
        }
      else
        {
          p = string + strcspn (string, " \t");
          if (*string == '!')
            string = NULL;
          else if (*p == '\0')
            continue;
          else
            *p++ = '\0';
        }

      frob_escapes (pattern, 1);
      if (string != NULL)
        frob_escapes (string, 0);

      n = regcomp (&re, pattern, flags);
      if (n != 0)
        {
          if (string != NULL)
            {
              char buf[500];
              regerror (n, &re, buf, sizeof (buf));
              printf ("FAIL regcomp unexpectedly failed: %s\n",
                      buf);
              ret = 1;
            }
          continue;
        }
      else if (string == NULL)
        {
          regfree (&re);
          puts ("FAIL regcomp unpexpectedly succeeded");
          ret = 1;
          continue;
        }

      if (regexec (&re, string, 20, rm, eflags))
        {
          for (i = 0; i < 20; ++i)
            {
              rm[i].rm_so = -1;
              rm[i].rm_eo = -1;
            }
        }

      regfree (&re);

      for (i = 0; i < 20 && *p != '\0'; ++i)
        {
          int rm_so, rm_eo;

          rm_so = strtol (p, &q, 10);
          if (p == q)
            break;
          p = q;

          rm_eo = strtol (p, &q, 10);
          if (p == q)
            break;
          p = q;

          if (rm[i].rm_so != rm_so || rm[i].rm_eo != rm_eo)
            {
              printf ("FAIL rm[%d] %d..%d != expected %d..%d\n",
                      i, rm[i].rm_so, rm[i].rm_eo, rm_so, rm_eo);
              ret = 1;
              break;
            }
        }
    }

  free (line);
  fclose (f);
  return ret;
}