win32: Import fnmatch source

This was extracted from commit e56b799d6ad8afba4168fffa7218d44c041a72d2
in Git repository.

4 files changed, 498 insertions, 1 deletions

diff --git a/Makefile b/Makefile
index 91cfd3cdc..c637d6d45 100644
--- a/Makefile
+++ b/Makefile
@@ -481,6 +481,7 @@ libs-y		:= \
                 sysklogd/ \
                 util-linux/ \
                 util-linux/volume_id/ \
+                win32/ \
 
 endif # KBUILD_EXTMOD
 
diff --git a/Makefile.flags b/Makefile.flags
index 0b5eea43b..920fee322 100644
--- a/Makefile.flags
+++ b/Makefile.flags
@@ -98,7 +98,8 @@ CFLAGS += $(strip $(subst ",,$(CONFIG_EXTRA_CFLAGS)))
 endif
 
 ifeq ($(CONFIG_PLATFORM_MINGW32),y)
-CFLAGS += -Iwin32
+# These defintions are not strictly needed, but they help shut up fnmatch.c warnings
+CFLAGS += -Iwin32 -DHAVE_STRING_H=1 -DHAVE_CONFIG_H=0
 EXEEXT = .exe
 else
 LDLIBS += m crypt
diff --git a/win32/Kbuild b/win32/Kbuild
new file mode 100644
index 000000000..df4fcb18d
--- /dev/null
+++ b/win32/Kbuild
@@ -0,0 +1,7 @@
+# Makefile for busybox
+#
+# Licensed under the GPL v2, see the file LICENSE in this tarball.
+
+lib-y:=
+
+lib-$(CONFIG_PLATFORM_MINGW32) += fnmatch.o
diff --git a/win32/fnmatch.c b/win32/fnmatch.c
new file mode 100644
index 000000000..1f4ead5f9
--- /dev/null
+++ b/win32/fnmatch.c
@@ -0,0 +1,488 @@
+/* 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__.  */