fnmatch: Use native on Unix, emulate on Win32

src/fnmatch.h

-/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-
-   The GNU C 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.
-
-   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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C 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.  */
-
-#ifndef	_FNMATCH_H
-#define	_FNMATCH_H	1
-
-#ifdef	__cplusplus
-extern "C" {
-#endif
-
-#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32
-# if !defined __GLIBC__ || !defined __P
-#  undef	__P
-#  define __P(protos)	protos
-# endif
-#else /* Not C++ or ANSI C.  */
-# undef	__P
-# define __P(protos)	()
-/* We can get away without defining `const' here only because in this file
-   it is used only inside the prototype for `fnmatch', which is elided in
-   non-ANSI C where `const' is problematical.  */
-#endif /* C++ or ANSI C.  */
-
-#ifndef const
-# if (defined __STDC__ && __STDC__) || defined __cplusplus
-#  define __const	const
-# else
-#  define __const
-# endif
-#endif
-
-/* We #undef these before defining them because some losing systems
-   (HP-UX A.08.07 for example) define these in <unistd.h>.  */
-#undef	FNM_PATHNAME
-#undef	FNM_NOESCAPE
-#undef	FNM_PERIOD
-
-/* Bits set in the FLAGS argument to `fnmatch'.  */
-#define	FNM_PATHNAME	(1 << 0) /* No wildcard can ever match `/'.  */
-#define	FNM_NOESCAPE	(1 << 1) /* Backslashes don't quote special chars.  */
-#define	FNM_PERIOD	(1 << 2) /* Leading `.' is matched only explicitly.  */
-
-#if !defined _POSIX_C_SOURCE || _POSIX_C_SOURCE < 2 || defined _GNU_SOURCE
-# define FNM_FILE_NAME	 FNM_PATHNAME	/* Preferred GNU name.  */
-# define FNM_LEADING_DIR (1 << 3)	/* Ignore `/...' after a match.  */
-# define FNM_CASEFOLD	 (1 << 4)	/* Compare without regard to case.  */
-#endif
-
-/* Value returned by `fnmatch' if STRING does not match PATTERN.  */
-#define	FNM_NOMATCH	1
-
-/* This value is returned if the implementation does not support
-   `fnmatch'.  Since this is not the case here it will never be
-   returned but the conformance test suites still require the symbol
-   to be defined.  */
-#ifdef _XOPEN_SOURCE
-# define FNM_NOSYS	(-1)
-#endif
-
-/* Match NAME against the filename pattern PATTERN,
-   returning zero if it matches, FNM_NOMATCH if not.  */
-extern int fnmatch __P ((__const char *__pattern, __const char *__name,
-			 int __flags));
-
-#ifdef	__cplusplus
-}
-#endif
-
-#endif /* fnmatch.h */

src/unix/posix.h

@@ -2,6 +2,7 @@
 #define INCLUDE_posix__w32_h__
 
 #include "common.h"
+#include <fnmatch.h>
 
 #define p_lstat(p,b) lstat(p,b)
 #define p_readlink(a, b, c) readlink(a, b, c)
@@ -10,5 +11,6 @@
 #define p_mkdir(p,m) mkdir(p, m)
 #define p_fsync(fd) fsync(fd)
 #define p_realpath(p, po) realpath(p, po)
+#define p_fnmatch(p, s, f) fnmatch(p, s, f)
 
 #endif

src/util.c

 #include <git2.h>
 #include "common.h"
-#include "fnmatch.h"
 #include <stdarg.h>
 #include <stdio.h>
 #include <ctype.h>
+#include "posix.h"
 
 #ifdef _MSV_VER
 # include <Shlwapi.h>
-#else
-# include <fnmatch.h>
 #endif
 
 void git_libgit2_version(int *major, int *minor, int *rev)
@@ -31,7 +29,7 @@ int git__fnmatch(const char *pattern, const char *name, int flags)
 {
 	int ret;
 
-	ret = fnmatch(pattern, name, flags);
+	ret = p_fnmatch(pattern, name, flags);
 	switch (ret) {
 	case 0:
 		return GIT_SUCCESS;

src/win32/fnmatch.c

+/*
+ * Copyright (c) 1989, 1993, 1994
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6.
+ * Compares a filename or pathname to a pattern.
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fnmatch.h"
+
+#define EOS        '\0'
+
+#define RANGE_MATCH        1
+#define RANGE_NOMATCH        0
+#define RANGE_ERROR        (-1)
+
+static int rangematch(const char *, char, int, char **);
+
+int
+p_fnmatch(const char *pattern, const char *string, int flags)
+{
+        const char *stringstart;
+        char *newp;
+        char c, test;
+
+        for (stringstart = string;;)
+                switch (c = *pattern++) {
+                case EOS:
+                        if ((flags & FNM_LEADING_DIR) && *string == '/')
+                                return (0);
+                        return (*string == EOS ? 0 : FNM_NOMATCH);
+                case '?':
+                        if (*string == EOS)
+                                return (FNM_NOMATCH);
+                        if (*string == '/' && (flags & FNM_PATHNAME))
+                                return (FNM_NOMATCH);
+                        if (*string == '.' && (flags & FNM_PERIOD) &&
+                            (string == stringstart ||
+                            ((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+                                return (FNM_NOMATCH);
+                        ++string;
+                        break;
+                case '*':
+                        c = *pattern;
+                        /* Collapse multiple stars. */
+                        while (c == '*')
+                                c = *++pattern;
+
+                        if (*string == '.' && (flags & FNM_PERIOD) &&
+                            (string == stringstart ||
+                            ((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+                                return (FNM_NOMATCH);
+
+                        /* Optimize for pattern with * at end or before /. */
+                        if (c == EOS) {
+                                if (flags & FNM_PATHNAME)
+                                        return ((flags & FNM_LEADING_DIR) ||
+                                            strchr(string, '/') == NULL ?
+                                            0 : FNM_NOMATCH);
+                                else
+                                        return (0);
+                        } else if (c == '/' && (flags & FNM_PATHNAME)) {
+                                if ((string = strchr(string, '/')) == NULL)
+                                        return (FNM_NOMATCH);
+                                break;
+                        }
+
+                        /* General case, use recursion. */
+                        while ((test = *string) != EOS) {
+                                if (!fnmatch(pattern, string, flags & ~FNM_PERIOD))
+                                        return (0);
+                                if (test == '/' && (flags & FNM_PATHNAME))
+                                        break;
+                                ++string;
+                        }
+                        return (FNM_NOMATCH);
+                case '[':
+                        if (*string == EOS)
+                                return (FNM_NOMATCH);
+                        if (*string == '/' && (flags & FNM_PATHNAME))
+                                return (FNM_NOMATCH);
+                        if (*string == '.' && (flags & FNM_PERIOD) &&
+                            (string == stringstart ||
+                            ((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+                                return (FNM_NOMATCH);
+
+                        switch (rangematch(pattern, *string, flags, &newp)) {
+                        case RANGE_ERROR:
+                                /* not a good range, treat as normal text */
+                                goto normal;
+                        case RANGE_MATCH:
+                                pattern = newp;
+                                break;
+                        case RANGE_NOMATCH:
+                                return (FNM_NOMATCH);
+                        }
+                        ++string;
+                        break;
+                case '\\':
+                        if (!(flags & FNM_NOESCAPE)) {
+                                if ((c = *pattern++) == EOS) {
+                                        c = '\\';
+                                        --pattern;
+                                }
+                        }
+                        /* FALLTHROUGH */
+                default:
+                normal:
+                        if (c != *string && !((flags & FNM_CASEFOLD) &&
+                                 (tolower((unsigned char)c) ==
+                                 tolower((unsigned char)*string))))
+                                return (FNM_NOMATCH);
+                        ++string;
+                        break;
+                }
+        /* NOTREACHED */
+}
+
+static int
+rangematch(const char *pattern, char test, int flags, char **newp)
+{
+        int negate, ok;
+        char c, c2;
+
+        /*
+         * A bracket expression starting with an unquoted circumflex
+         * character produces unspecified results (IEEE 1003.2-1992,
+         * 3.13.2).  This implementation treats it like '!', for
+         * consistency with the regular expression syntax.
+         * J.T. Conklin (conklin@ngai.kaleida.com)
+         */
+        if ((negate = (*pattern == '!' || *pattern == '^')))
+                ++pattern;
+
+        if (flags & FNM_CASEFOLD)
+                test = (char)tolower((unsigned char)test);
+
+        /*
+         * A right bracket shall lose its special meaning and represent
+         * itself in a bracket expression if it occurs first in the list.
+         * -- POSIX.2 2.8.3.2
+         */
+        ok = 0;
+        c = *pattern++;
+        do {
+                if (c == '\\' && !(flags & FNM_NOESCAPE))
+                        c = *pattern++;
+                if (c == EOS)
+                        return (RANGE_ERROR);
+                if (c == '/' && (flags & FNM_PATHNAME))
+                        return (RANGE_NOMATCH);
+                if ((flags & FNM_CASEFOLD))
+                        c = (char)tolower((unsigned char)c);
+                if (*pattern == '-'
+                    && (c2 = *(pattern+1)) != EOS && c2 != ']') {
+                        pattern += 2;
+                        if (c2 == '\\' && !(flags & FNM_NOESCAPE))
+                                c2 = *pattern++;
+                        if (c2 == EOS)
+                                return (RANGE_ERROR);
+                        if (flags & FNM_CASEFOLD)
+                                c2 = (char)tolower((unsigned char)c2);
+                        if (c <= test && test <= c2)
+                                ok = 1;
+                } else if (c == test)
+                        ok = 1;
+        } while ((c = *pattern++) != ']');
+
+        *newp = (char *)pattern;
+        return (ok == negate ? RANGE_NOMATCH : RANGE_MATCH);
+}
+

src/win32/fnmatch.h

+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#ifndef INCLUDE_fnmatch__w32_h__
+#define INCLUDE_fnmatch__w32_h__
+
+#include "common.h"
+
+#define FNM_NOMATCH      1     /* Match failed. */
+#define FNM_NOSYS        2     /* Function not supported (unused). */
+
+#define FNM_NOESCAPE     0x01        /* Disable backslash escaping. */
+#define FNM_PATHNAME     0x02        /* Slash must be matched by slash. */
+#define FNM_PERIOD       0x04        /* Period must be matched by period. */
+#define FNM_LEADING_DIR  0x08        /* Ignore /<tail> after Imatch. */
+#define FNM_CASEFOLD     0x10        /* Case insensitive search. */
+
+#define FNM_IGNORECASE   FNM_CASEFOLD
+#define FNM_FILE_NAME    FNM_PATHNAME
+
+extern int p_fnmatch(const char *pattern, const char *string, int flags);
+
+#endif /* _FNMATCH_H */
+

src/win32/posix.h

@@ -2,6 +2,7 @@
 #define INCLUDE_posix__w32_h__
 
 #include "common.h"
+#include "fnmatch.h"
 
 GIT_INLINE(int) p_link(const char *GIT_UNUSED(old), const char *GIT_UNUSED(new))
 {