| /* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 |
| 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__. */ |