2 * Copyright (c) 1989, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 /* OpenBSD: fnmatch.c,v 1.6 1998/03/19 00:29:59 millert */
36 * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6.
37 * Compares a filename or pathname to a pattern.
42 /* Define SYS to use the system fnmatch() rather than ours */
56 #define RANGE_NOMATCH 0
57 #define RANGE_ERROR (-1)
59 /* Limit of recursion during matching attempts. */
60 #define FNM_MAX_RECUR 64
62 #define ISSET(x, y) ((x) & (y))
63 #define FOLD(c) ((flags & FNM_CASEFOLD) && B_ISUPPER(c) ? tolower(c) : (c))
65 static int rangematch(const char *, char, int, char **);
66 static int r_fnmatch(const char *, const char *, int, int);
69 int xfnmatch(const char *pattern, const char *string, int flags)
71 int fnmatch(const char *pattern, const char *string, int flags)
76 e = r_fnmatch(pattern, string, flags, FNM_MAX_RECUR);
77 if (e == -1) { /* Too much recursion */
84 int r_fnmatch(const char *pattern, const char *string, int flags, int recur)
86 const char *stringstart;
97 switch (c = *pattern++) {
99 if (ISSET(flags, FNM_LEADING_DIR) && IsPathSeparator(*string))
101 return (*string == EOS ? 0 : FNM_NOMATCH);
104 return (FNM_NOMATCH);
105 if (IsPathSeparator(*string) && ISSET(flags, FNM_PATHNAME))
106 return (FNM_NOMATCH);
107 if (*string == '.' && ISSET(flags, FNM_PERIOD) &&
108 (string == stringstart ||
109 (ISSET(flags, FNM_PATHNAME) && IsPathSeparator(*(string - 1)))))
110 return (FNM_NOMATCH);
115 /* Collapse multiple stars. */
120 if (*string == '.' && ISSET(flags, FNM_PERIOD) &&
121 (string == stringstart ||
122 (ISSET(flags, FNM_PATHNAME) && IsPathSeparator(*(string - 1))))) {
123 return (FNM_NOMATCH);
126 /* Optimize for pattern with * at end or before /. */
128 if (ISSET(flags, FNM_PATHNAME)) {
129 return (ISSET(flags, FNM_LEADING_DIR) ||
130 strchr(string, '/') == NULL ? 0 : FNM_NOMATCH);
134 } else if (IsPathSeparator(c) && ISSET(flags, FNM_PATHNAME)) {
135 if ((string = strchr(string, '/')) == NULL)
136 return (FNM_NOMATCH);
140 /* General case, use recursion. */
141 while ((test = *string) != EOS) {
142 e = r_fnmatch(pattern, string, flags & ~FNM_PERIOD, recur);
143 if (e != FNM_NOMATCH) { /* can be NOMATCH, -1 or MATCH */
146 if (test == '/' && ISSET(flags, FNM_PATHNAME)) {
151 return (FNM_NOMATCH);
154 return (FNM_NOMATCH);
155 if (IsPathSeparator(*string) && ISSET(flags, FNM_PATHNAME))
156 return (FNM_NOMATCH);
157 if (*string == '.' && ISSET(flags, FNM_PERIOD) &&
158 (string == stringstart ||
159 (ISSET(flags, FNM_PATHNAME) && IsPathSeparator(*(string - 1)))))
160 return (FNM_NOMATCH);
162 switch (rangematch(pattern, *string, flags, &newp)) {
164 /* not a good range, treat as normal text */
170 return (FNM_NOMATCH);
176 if (!ISSET(flags, FNM_NOESCAPE)) {
177 if ((c = *pattern++) == EOS) {
185 if (FOLD(c) != FOLD(*string)) {
186 return (FNM_NOMATCH);
195 static int rangematch(const char *pattern, char test, int flags,
202 * A bracket expression starting with an unquoted circumflex
203 * character produces unspecified results (IEEE 1003.2-1992,
204 * 3.13.2). This implementation treats it like '!', for
205 * consistency with the regular expression syntax.
206 * J.T. Conklin (conklin@ngai.kaleida.com)
208 if ((negate = (*pattern == '!' || *pattern == '^')))
214 * A right bracket shall lose its special meaning and represent
215 * itself in a bracket expression if it occurs first in the list.
221 if (c == '\\' && !ISSET(flags, FNM_NOESCAPE))
224 return (RANGE_ERROR);
225 if (c == '/' && ISSET(flags, FNM_PATHNAME))
226 return (RANGE_NOMATCH);
228 if (*pattern == '-' && (c2 = *(pattern + 1)) != EOS && c2 != ']') {
230 if (c2 == '\\' && !ISSET(flags, FNM_NOESCAPE))
233 return (RANGE_ERROR);
235 if (c <= test && test <= c2)
237 } else if (c == test)
239 } while ((c = *pattern++) != ']');
241 *newp = (char *) pattern;
242 return (ok == negate ? RANGE_NOMATCH : RANGE_MATCH);
254 * Note, some of these tests were duplicated from a patch file I found
255 * in an email, so I am unsure what the license is. Since this code is
256 * never turned on in any release, it probably doesn't matter at all.
257 * If by some chance someone finds this to be a problem please let
260 static struct test tests[] = {
261 /*1*/ {"x", "x", FNM_PATHNAME | FNM_LEADING_DIR, 0},
262 {"x", "x/y", FNM_PATHNAME | FNM_LEADING_DIR, 0},
263 {"x", "x/y/z", FNM_PATHNAME | FNM_LEADING_DIR, 0},
264 {"*", "x", FNM_PATHNAME | FNM_LEADING_DIR, 0},
265 /*5*/ {"*", "x/y", FNM_PATHNAME | FNM_LEADING_DIR, 0},
266 {"*", "x/y/z", FNM_PATHNAME | FNM_LEADING_DIR, 0},
267 {"*x", "x", FNM_PATHNAME | FNM_LEADING_DIR, 0},
268 {"*x", "x/y", FNM_PATHNAME | FNM_LEADING_DIR, 0},
269 {"*x", "x/y/z", FNM_PATHNAME | FNM_LEADING_DIR, 0},
270 /*10*/ {"x*", "x", FNM_PATHNAME | FNM_LEADING_DIR, 0},
271 {"x*", "x/y", FNM_PATHNAME | FNM_LEADING_DIR, 0},
272 {"x*", "x/y/z", FNM_PATHNAME | FNM_LEADING_DIR, 0},
273 {"a*b/*", "abbb/.x", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH},
274 {"a*b/*", "abbb/xy", FNM_PATHNAME|FNM_PERIOD, 0},
275 /*15*/ {"[A-[]", "A", 0, 0},
276 {"[A-[]", "a", 0, FNM_NOMATCH},
277 {"[a-{]", "A", 0, FNM_NOMATCH},
278 {"[a-{]", "a", 0, 0},
279 {"[A-[]", "A", FNM_CASEFOLD, FNM_NOMATCH},
280 /*20*/ {"[A-[]", "a", FNM_CASEFOLD, FNM_NOMATCH},
281 {"[a-{]", "A", FNM_CASEFOLD, 0},
282 {"[a-{]", "a", FNM_CASEFOLD, 0},
283 { "*LIB*", "lib", FNM_PERIOD, FNM_NOMATCH },
284 { "*LIB*", "lib", FNM_CASEFOLD, 0},
285 /*25*/ { "a[/]b", "a/b", 0, 0},
286 { "a[/]b", "a/b", FNM_PATHNAME, FNM_NOMATCH },
287 { "[a-z]/[a-z]", "a/b", 0, 0 },
288 { "a/b", "*", FNM_PATHNAME, FNM_NOMATCH },
289 { "*", "a/b", FNM_PATHNAME, FNM_NOMATCH },
290 { "*[/]b", "a/b", FNM_PATHNAME, FNM_NOMATCH },
291 /*30*/ { "\\[/b", "[/b", 0, 0 },
292 { "?\?/b", "aa/b", 0, 0 },
293 { "???b", "aa/b", 0, 0 },
294 { "???b", "aa/b", FNM_PATHNAME, FNM_NOMATCH },
295 { "?a/b", ".a/b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
296 /*35*/ { "a/?b", "a/.b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
297 { "*a/b", ".a/b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
298 { "a/*b", "a/.b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
299 { "[.]a/b", ".a/b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
300 { "a/[.]b", "a/.b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
301 /*40*/ { "*/?", "a/b", FNM_PATHNAME|FNM_PERIOD, 0 },
302 { "?/*", "a/b", FNM_PATHNAME|FNM_PERIOD, 0 },
303 { ".*/?", ".a/b", FNM_PATHNAME|FNM_PERIOD, 0 },
304 { "*/.?", "a/.b", FNM_PATHNAME|FNM_PERIOD, 0 },
305 { "*/*", "a/.b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
306 /*45*/ { "*[.]/b", "a./b", FNM_PATHNAME|FNM_PERIOD, 0 },
307 { "a?b", "a.b", FNM_PATHNAME|FNM_PERIOD, 0 },
308 { "a*b", "a.b", FNM_PATHNAME|FNM_PERIOD, 0 },
309 { "a[.]b", "a.b", FNM_PATHNAME|FNM_PERIOD, 0 },
310 /*49*/ { "*a*", "a/b", FNM_PATHNAME|FNM_LEADING_DIR, 0 },
311 { "[/b", "[/b", 0, 0},
313 /* This test takes a *long* time */
314 {"a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*",
315 "aaaabbbbccccddddeeeeffffgggghhhhiiiijjjjkkkkllllmmmm"
316 "nnnnooooppppqqqqrrrrssssttttuuuuvvvvwwwwxxxxyyyy", 0, FNM_NOMATCH},
319 /* Keep dummy last to avoid compiler warnings */
320 {"dummy", "dummy", 0, 0}
324 #define ntests ((int)(sizeof(tests)/sizeof(struct test)))
329 for (int i=0; i<ntests; i++) {
330 if (fnmatch(tests[i].pattern, tests[i].string, tests[i].options) != tests[i].result) {
331 printf("Test %d failed: pat=%s str=%s expect=%s got=%s\n",
332 i+1, tests[i].pattern, tests[i].string,
333 tests[i].result==0?"matches":"no match",
334 tests[i].result==0?"no match":"matches");
337 printf("Test %d succeeded\n", i+1);
342 #endif /* TEST_PROGRAM */