de45941f8f98c1064335bb1b1a01522c225d19ee
[kopensolaris-gnu/glibc.git] / posix / fnmatch.c
1 /* Copyright (C) 1991, 1992, 1993, 1996 Free Software Foundation, Inc.
2
3 This library is free software; you can redistribute it and/or
4 modify it under the terms of the GNU Library General Public License as
5 published by the Free Software Foundation; either version 2 of the
6 License, or (at your option) any later version.
7
8 This library is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 Library General Public License for more details.
12
13 You should have received a copy of the GNU Library General Public
14 License along with this library; see the file COPYING.LIB.  If
15 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
16 Cambridge, MA 02139, USA.  */
17
18 #ifdef HAVE_CONFIG_H
19 #include <config.h>
20 #endif
21
22 /* Enable GNU extensions in fnmatch.h.  */
23 #ifndef _GNU_SOURCE
24 #define _GNU_SOURCE     1
25 #endif
26
27 #include <errno.h>
28 #include <fnmatch.h>
29 #include <ctype.h>
30
31
32 /* Comment out all this code if we are using the GNU C Library, and are not
33    actually compiling the library itself.  This code is part of the GNU C
34    Library, but also included in many other GNU distributions.  Compiling
35    and linking in this code is a waste when using the GNU C library
36    (especially if it is a shared library).  Rather than having every GNU
37    program understand `configure --with-gnu-libc' and omit the object files,
38    it is simpler to just do this in the source for each such file.  */
39
40 #if defined (_LIBC) || !defined (__GNU_LIBRARY__)
41
42
43 #ifndef errno
44 extern int errno;
45 #endif
46
47 /* Match STRING against the filename pattern PATTERN, returning zero if
48    it matches, nonzero if not.  */
49 int
50 fnmatch (pattern, string, flags)
51      const char *pattern;
52      const char *string;
53      int flags;
54 {
55   register const char *p = pattern, *n = string;
56   register char c;
57
58 /* Note that this evalutes C many times.  */
59 #define FOLD(c) ((flags & FNM_CASEFOLD) && isupper (c) ? tolower (c) : (c))
60
61   while ((c = *p++) != '\0')
62     {
63       c = FOLD (c);
64
65       switch (c)
66         {
67         case '?':
68           if (*n == '\0')
69             return FNM_NOMATCH;
70           else if ((flags & FNM_FILE_NAME) && *n == '/')
71             return FNM_NOMATCH;
72           else if ((flags & FNM_PERIOD) && *n == '.' &&
73                    (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
74             return FNM_NOMATCH;
75           break;
76
77         case '\\':
78           if (!(flags & FNM_NOESCAPE))
79             {
80               c = *p++;
81               if (c == '\0')
82                 /* Trailing \ loses.  */
83                 return FNM_NOMATCH;
84               c = FOLD (c);
85             }
86           if (FOLD (*n) != c)
87             return FNM_NOMATCH;
88           break;
89
90         case '*':
91           if ((flags & FNM_PERIOD) && *n == '.' &&
92               (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
93             return FNM_NOMATCH;
94
95           for (c = *p++; c == '?' || c == '*'; c = *p++)
96             {
97               if ((flags & FNM_FILE_NAME) && *n == '/')
98                 /* A slash does not match a wildcard under FNM_FILE_NAME.  */
99                 return FNM_NOMATCH;
100               else if (c == '?')
101                 {
102                   /* A ? needs to match one character.  */
103                   if (*n == '\0')
104                     /* There isn't another character; no match.  */
105                     return FNM_NOMATCH;
106                   else
107                     /* One character of the string is consumed in matching
108                        this ? wildcard, so *??? won't match if there are
109                        less than three characters.  */
110                     ++n;
111                 }
112             }
113
114           if (c == '\0')
115             return 0;
116
117           {
118             char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c;
119             c1 = FOLD (c1);
120             for (--p; *n != '\0'; ++n)
121               if ((c == '[' || FOLD (*n) == c1) &&
122                   fnmatch (p, n, flags & ~FNM_PERIOD) == 0)
123                 return 0;
124             return FNM_NOMATCH;
125           }
126
127         case '[':
128           {
129             /* Nonzero if the sense of the character class is inverted.  */
130             register int not;
131
132             if (*n == '\0')
133               return FNM_NOMATCH;
134
135             if ((flags & FNM_PERIOD) && *n == '.' &&
136                 (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
137               return FNM_NOMATCH;
138
139             not = (*p == '!' || *p == '^');
140             if (not)
141               ++p;
142
143             c = *p++;
144             for (;;)
145               {
146                 register char cstart = c, cend = c;
147
148                 if (!(flags & FNM_NOESCAPE) && c == '\\')
149                   {
150                     if (*p == '\0')
151                       return FNM_NOMATCH;
152                     cstart = cend = *p++;
153                   }
154
155                 cstart = cend = FOLD (cstart);
156
157                 if (c == '\0')
158                   /* [ (unterminated) loses.  */
159                   return FNM_NOMATCH;
160
161                 c = *p++;
162                 c = FOLD (c);
163
164                 if ((flags & FNM_FILE_NAME) && c == '/')
165                   /* [/] can never match.  */
166                   return FNM_NOMATCH;
167
168                 if (c == '-' && *p != ']')
169                   {
170                     cend = *p++;
171                     if (!(flags & FNM_NOESCAPE) && cend == '\\')
172                       cend = *p++;
173                     if (cend == '\0')
174                       return FNM_NOMATCH;
175                     cend = FOLD (cend);
176
177                     c = *p++;
178                   }
179
180                 if (FOLD (*n) >= cstart && FOLD (*n) <= cend)
181                   goto matched;
182
183                 if (c == ']')
184                   break;
185               }
186             if (!not)
187               return FNM_NOMATCH;
188             break;
189
190           matched:;
191             /* Skip the rest of the [...] that already matched.  */
192             while (c != ']')
193               {
194                 if (c == '\0')
195                   /* [... (unterminated) loses.  */
196                   return FNM_NOMATCH;
197
198                 c = *p++;
199                 if (!(flags & FNM_NOESCAPE) && c == '\\')
200                   {
201                     if (*p == '\0')
202                       return FNM_NOMATCH;
203                     /* XXX 1003.2d11 is unclear if this is right.  */
204                     ++p;
205                   }
206               }
207             if (not)
208               return FNM_NOMATCH;
209           }
210           break;
211
212         default:
213           if (c != FOLD (*n))
214             return FNM_NOMATCH;
215         }
216
217       ++n;
218     }
219
220   if (*n == '\0')
221     return 0;
222
223   if ((flags & FNM_LEADING_DIR) && *n == '/')
224     /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz".  */
225     return 0;
226
227   return FNM_NOMATCH;
228 }
229
230 #endif  /* _LIBC or not __GNU_LIBRARY__.  */