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

fnmatch.c

/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

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

   This 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#if HAVE_CONFIG_H
# include <config.h>
#endif

/* Enable GNU extensions in fnmatch.h.  */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE    1
#endif

#include <errno.h>
#include <fnmatch.h>
#include <ctype.h>

#if HAVE_STRING_H || defined _LIBC
# include <string.h>
#else
# include <strings.h>
#endif

#if defined STDC_HEADERS || defined _LIBC
# include <stdlib.h>
#endif

/* For platform which support the ISO C amendement 1 functionality we
   support user defined character classes.  */
#if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
# include <wchar.h>
# include <wctype.h>
#endif

/* Comment out all this code if we are using the GNU C Library, and are not
   actually compiling the library itself.  This code is part of the GNU C
   Library, but also included in many other GNU distributions.  Compiling
   and linking in this code is a waste when using the GNU C library
   (especially if it is a shared library).  Rather than having every GNU
   program understand `configure --with-gnu-libc' and omit the object files,
   it is simpler to just do this in the source for each such file.  */

#if defined _LIBC || !defined __GNU_LIBRARY__


# if defined STDC_HEADERS || !defined isascii
#  define ISASCII(c) 1
# else
#  define ISASCII(c) isascii(c)
# endif

# ifdef isblank
#  define ISBLANK(c) (ISASCII (c) && isblank (c))
# else
#  define ISBLANK(c) ((c) == ' ' || (c) == '\t')
# endif
# ifdef isgraph
#  define ISGRAPH(c) (ISASCII (c) && isgraph (c))
# else
#  define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
# endif

# define ISPRINT(c) (ISASCII (c) && isprint (c))
# define ISDIGIT(c) (ISASCII (c) && isdigit (c))
# define ISALNUM(c) (ISASCII (c) && isalnum (c))
# define ISALPHA(c) (ISASCII (c) && isalpha (c))
# define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
# define ISLOWER(c) (ISASCII (c) && islower (c))
# define ISPUNCT(c) (ISASCII (c) && ispunct (c))
# define ISSPACE(c) (ISASCII (c) && isspace (c))
# define ISUPPER(c) (ISASCII (c) && isupper (c))
# define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))

# define STREQ(s1, s2) ((strcmp (s1, s2) == 0))

# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
/* The GNU C library provides support for user-defined character classes
   and the functions from ISO C amendement 1.  */
#  ifdef CHARCLASS_NAME_MAX
#   define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
#  else
/* This shouldn't happen but some implementation might still have this
   problem.  Use a reasonable default value.  */
#   define CHAR_CLASS_MAX_LENGTH 256
#  endif

#  ifdef _LIBC
#   define IS_CHAR_CLASS(string) __wctype (string)
#  else
#   define IS_CHAR_CLASS(string) wctype (string)
#  endif
# else
#  define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */

#  define IS_CHAR_CLASS(string)                                         \
   (STREQ (string, "alpha") || STREQ (string, "upper")                        \
    || STREQ (string, "lower") || STREQ (string, "digit")               \
    || STREQ (string, "alnum") || STREQ (string, "xdigit")              \
    || STREQ (string, "space") || STREQ (string, "print")               \
    || STREQ (string, "punct") || STREQ (string, "graph")               \
    || STREQ (string, "cntrl") || STREQ (string, "blank"))
# endif

/* Avoid depending on library functions or files
   whose names are inconsistent.  */

# if !defined _LIBC && !defined getenv
extern char *getenv ();
# endif

# ifndef errno
extern int errno;
# endif

/* This function doesn't exist on most systems.  */

# if !defined HAVE___STRCHRNUL && !defined _LIBC
static char *
__strchrnul (s, c)
     const char *s;
     int c;
{
  char *result = strchr (s, c);
  if (result == NULL)
    result = strchr (s, '\0');
  return result;
}
# endif

# ifndef internal_function
/* Inside GNU libc we mark some function in a special way.  In other
   environments simply ignore the marking.  */
#  define internal_function
# endif

/* Match STRING against the filename pattern PATTERN, returning zero if
   it matches, nonzero if not.  */
static int internal_fnmatch __P ((const char *pattern, const char *string,
                          int no_leading_period, int flags))
     internal_function;
static int
internal_function
internal_fnmatch (pattern, string, no_leading_period, flags)
     const char *pattern;
     const char *string;
     int no_leading_period;
     int flags;
{
  register const char *p = pattern, *n = string;
  register unsigned char c;

/* Note that this evaluates C many times.  */
# ifdef _LIBC
#  define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c))
# else
#  define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c))
# endif

  while ((c = *p++) != '\0')
    {
      c = FOLD (c);

      switch (c)
      {
      case '?':
        if (*n == '\0')
          return FNM_NOMATCH;
        else if (*n == '/' && (flags & FNM_FILE_NAME))
          return FNM_NOMATCH;
        else if (*n == '.' && no_leading_period
               && (n == string
                   || (n[-1] == '/' && (flags & FNM_FILE_NAME))))
          return FNM_NOMATCH;
        break;

      case '\\':
        if (!(flags & FNM_NOESCAPE))
          {
            c = *p++;
            if (c == '\0')
            /* Trailing \ loses.  */
            return FNM_NOMATCH;
            c = FOLD (c);
          }
        if (FOLD ((unsigned char) *n) != c)
          return FNM_NOMATCH;
        break;

      case '*':
        if (*n == '.' && no_leading_period
            && (n == string
              || (n[-1] == '/' && (flags & FNM_FILE_NAME))))
          return FNM_NOMATCH;

        for (c = *p++; c == '?' || c == '*'; c = *p++)
          {
            if (*n == '/' && (flags & FNM_FILE_NAME))
            /* A slash does not match a wildcard under FNM_FILE_NAME.  */
            return FNM_NOMATCH;
            else if (c == '?')
            {
              /* A ? needs to match one character.  */
              if (*n == '\0')
                /* There isn't another character; no match.  */
                return FNM_NOMATCH;
              else
                /* One character of the string is consumed in matching
                   this ? wildcard, so *??? won't match if there are
                   less than three characters.  */
                ++n;
            }
          }

        if (c == '\0')
          /* The wildcard(s) is/are the last element of the pattern.
             If the name is a file name and contains another slash
             this does mean it cannot match.  */
          return ((flags & FNM_FILE_NAME) && strchr (n, '/') != NULL
                ? FNM_NOMATCH : 0);
        else
          {
            const char *endp;

            endp = __strchrnul (n, (flags & FNM_FILE_NAME) ? '/' : '\0');

            if (c == '[')
            {
              int flags2 = ((flags & FNM_FILE_NAME)
                        ? flags : (flags & ~FNM_PERIOD));

              for (--p; n < endp; ++n)
                if (internal_fnmatch (p, n,
                                (no_leading_period
                                 && (n == string
                                     || (n[-1] == '/'
                                       && (flags
                                           & FNM_FILE_NAME)))),
                                flags2)
                  == 0)
                  return 0;
            }
            else if (c == '/' && (flags & FNM_FILE_NAME))
            {
              while (*n != '\0' && *n != '/')
                ++n;
              if (*n == '/'
                  && (internal_fnmatch (p, n + 1, flags & FNM_PERIOD,
                                  flags) == 0))
                return 0;
            }
            else
            {
              int flags2 = ((flags & FNM_FILE_NAME)
                        ? flags : (flags & ~FNM_PERIOD));

              if (c == '\\' && !(flags & FNM_NOESCAPE))
                c = *p;
              c = FOLD (c);
              for (--p; n < endp; ++n)
                if (FOLD ((unsigned char) *n) == c
                  && (internal_fnmatch (p, n,
                                    (no_leading_period
                                     && (n == string
                                       || (n[-1] == '/'
                                           && (flags
                                             & FNM_FILE_NAME)))),
                                    flags2) == 0))
                  return 0;
            }
          }

        /* If we come here no match is possible with the wildcard.  */
        return FNM_NOMATCH;

      case '[':
        {
          /* Nonzero if the sense of the character class is inverted.  */
          static int posixly_correct;
          register int not;
          char cold;

          if (posixly_correct == 0)
            posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;

          if (*n == '\0')
            return FNM_NOMATCH;

          if (*n == '.' && no_leading_period && (n == string
                                       || (n[-1] == '/'
                                           && (flags
                                             & FNM_FILE_NAME))))
            return FNM_NOMATCH;

          if (*n == '/' && (flags & FNM_FILE_NAME))
            /* `/' cannot be matched.  */
            return FNM_NOMATCH;

          not = (*p == '!' || (posixly_correct < 0 && *p == '^'));
          if (not)
            ++p;

          c = *p++;
          for (;;)
            {
            unsigned char fn = FOLD ((unsigned char) *n);

            if (!(flags & FNM_NOESCAPE) && c == '\\')
              {
                if (*p == '\0')
                  return FNM_NOMATCH;
                c = FOLD ((unsigned char) *p);
                ++p;

                if (c == fn)
                  goto matched;
              }
            else if (c == '[' && *p == ':')
              {
                /* Leave room for the null.  */
                char str[CHAR_CLASS_MAX_LENGTH + 1];
                size_t c1 = 0;
# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
                wctype_t wt;
# endif
                const char *startp = p;

                for (;;)
                  {
                  if (c1 == CHAR_CLASS_MAX_LENGTH)
                    /* The name is too long and therefore the pattern
                       is ill-formed.  */
                    return FNM_NOMATCH;

                  c = *++p;
                  if (c == ':' && p[1] == ']')
                    {
                      p += 2;
                      break;
                    }
                  if (c < 'a' || c >= 'z')
                    {
                      /* This cannot possibly be a character class name.
                         Match it as a normal range.  */
                      p = startp;
                      c = '[';
                      goto normal_bracket;
                    }
                  str[c1++] = c;
                  }
                str[c1] = '\0';

# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
                wt = IS_CHAR_CLASS (str);
                if (wt == 0)
                  /* Invalid character class name.  */
                  return FNM_NOMATCH;

                if (__iswctype (__btowc ((unsigned char) *n), wt))
                  goto matched;
# else
                if ((STREQ (str, "alnum") && ISALNUM ((unsigned char) *n))
                  || (STREQ (str, "alpha") && ISALPHA ((unsigned char) *n))
                  || (STREQ (str, "blank") && ISBLANK ((unsigned char) *n))
                  || (STREQ (str, "cntrl") && ISCNTRL ((unsigned char) *n))
                  || (STREQ (str, "digit") && ISDIGIT ((unsigned char) *n))
                  || (STREQ (str, "graph") && ISGRAPH ((unsigned char) *n))
                  || (STREQ (str, "lower") && ISLOWER ((unsigned char) *n))
                  || (STREQ (str, "print") && ISPRINT ((unsigned char) *n))
                  || (STREQ (str, "punct") && ISPUNCT ((unsigned char) *n))
                  || (STREQ (str, "space") && ISSPACE ((unsigned char) *n))
                  || (STREQ (str, "upper") && ISUPPER ((unsigned char) *n))
                  || (STREQ (str, "xdigit") && ISXDIGIT ((unsigned char) *n)))
                  goto matched;
# endif
              }
            else if (c == '\0')
              /* [ (unterminated) loses.  */
              return FNM_NOMATCH;
            else
              {
              normal_bracket:
                if (FOLD (c) == fn)
                  goto matched;

                cold = c;
                c = *p++;

                if (c == '-' && *p != ']')
                  {
                  /* It is a range.  */
                  unsigned char cend = *p++;
                  if (!(flags & FNM_NOESCAPE) && cend == '\\')
                    cend = *p++;
                  if (cend == '\0')
                    return FNM_NOMATCH;

                  if (cold <= fn && fn <= FOLD (cend))
                    goto matched;

                  c = *p++;
                  }
              }

            if (c == ']')
              break;
            }

          if (!not)
            return FNM_NOMATCH;
          break;

        matched:
          /* Skip the rest of the [...] that already matched.  */
          while (c != ']')
            {
            if (c == '\0')
              /* [... (unterminated) loses.  */
              return FNM_NOMATCH;

            c = *p++;
            if (!(flags & FNM_NOESCAPE) && c == '\\')
              {
                if (*p == '\0')
                  return FNM_NOMATCH;
                /* XXX 1003.2d11 is unclear if this is right.  */
                ++p;
              }
            else if (c == '[' && *p == ':')
              {
                do
                  if (*++p == '\0')
                  return FNM_NOMATCH;
                while (*p != ':' || p[1] == ']');
                p += 2;
                c = *p;
              }
            }
          if (not)
            return FNM_NOMATCH;
        }
        break;

      default:
        if (c != FOLD ((unsigned char) *n))
          return FNM_NOMATCH;
      }

      ++n;
    }

  if (*n == '\0')
    return 0;

  if ((flags & FNM_LEADING_DIR) && *n == '/')
    /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz".  */
    return 0;

  return FNM_NOMATCH;

# undef FOLD
}


int
fnmatch (pattern, string, flags)
     const char *pattern;
     const char *string;
     int flags;
{
  return internal_fnmatch (pattern, string, flags & FNM_PERIOD, flags);
}

#endif      /* _LIBC or not __GNU_LIBRARY__.  */

Generated by  Doxygen 1.6.0   Back to index