Revert unintended parts of previous commit.

1 files changed, 0 insertions, 146 deletions

diff --git a/openbsd-compat/bsd-cygwin_util.c b/openbsd-compat/bsd-cygwin_util.c
index f721fca9d..fb49e30f5 100644
--- a/openbsd-compat/bsd-cygwin_util.c
+++ b/openbsd-compat/bsd-cygwin_util.c
@@ -37,8 +37,6 @@
 #include <string.h>
 #include <unistd.h>
 #include <stdarg.h>
-#include <wchar.h>
-#include <wctype.h>
 
 #include "xmalloc.h"
 
@@ -119,148 +117,4 @@ free_windows_environment(char **p)
         free(p);
 }
 
-/*
- * Returns true if the given string matches the pattern (which may contain ?
- * and * as wildcards), and zero if it does not match.
- *
- * The Cygwin version of this function must be case-insensitive and take
- * Unicode characters into account.
- */
-
-static int
-__match_pattern (const wchar_t *s, const wchar_t *pattern, int caseinsensitive)
-{
-        for (;;) {
-                /* If at end of pattern, accept if also at end of string. */
-                if (!*pattern)
-                        return !*s;
-
-                if (*pattern == '*') {
-                        /* Skip the asterisk. */
-                        pattern++;
-
-                        /* If at end of pattern, accept immediately. */
-                        if (!*pattern)
-                                return 1;
-
-                        /* If next character in pattern is known, optimize. */
-                        if (*pattern != '?' && *pattern != '*') {
-                                /*
-                                 * Look instances of the next character in
-                                 * pattern, and try to match starting from
-                                 * those.
-                                 */
-                                for (; *s; s++)
-                                        if (*s == *pattern &&
-                                            __match_pattern(s + 1, pattern + 1,
-                                                            caseinsensitive))
-                                                return 1;
-                                /* Failed. */
-                                return 0;
-                        }
-                        /*
-                         * Move ahead one character at a time and try to
-                         * match at each position.
-                         */
-                        for (; *s; s++)
-                                if (__match_pattern(s, pattern, caseinsensitive))
-                                        return 1;
-                        /* Failed. */
-                        return 0;
-                }
-                /*
-                 * There must be at least one more character in the string.
-                 * If we are at the end, fail.
-                 */
-                if (!*s)
-                        return 0;
-
-                /* Check if the next character of the string is acceptable. */
-                if (*pattern != '?' && (*pattern != *s &&
-                     (!caseinsensitive || towlower(*pattern) != towlower(*s))))
-                        return 0;
-
-                /* Move to the next character, both in string and in pattern. */
-                s++;
-                pattern++;
-        }
-        /* NOTREACHED */
-}
-
-static int
-_match_pattern(const char *s, const char *pattern, int caseinsensitive)
-{
-        wchar_t *ws;
-        wchar_t *wpattern;
-        size_t len;
-
-        if ((len = mbstowcs(NULL, s, 0)) < 0)
-                return 0;
-        ws = (wchar_t *) alloca((len + 1) * sizeof (wchar_t));
-        mbstowcs(ws, s, len + 1);
-        if ((len = mbstowcs(NULL, pattern, 0)) < 0)
-                return 0;
-        wpattern = (wchar_t *) alloca((len + 1) * sizeof (wchar_t));
-        mbstowcs(wpattern, pattern, len + 1);
-        return __match_pattern (ws, wpattern, caseinsensitive);
-}
-
-/*
- * Tries to match the string against the
- * comma-separated sequence of subpatterns (each possibly preceded by ! to
- * indicate negation).  Returns -1 if negation matches, 1 if there is
- * a positive match, 0 if there is no match at all.
- */
-int
-match_pattern_list(const char *string, const char *pattern, int caseinsensitive)
-{
-        char sub[1024];
-        int negated;
-        int got_positive;
-        u_int i, subi, len = strlen(pattern);
-
-        got_positive = 0;
-        for (i = 0; i < len;) {
-                /* Check if the subpattern is negated. */
-                if (pattern[i] == '!') {
-                        negated = 1;
-                        i++;
-                } else
-                        negated = 0;
-
-                /*
-                 * Extract the subpattern up to a comma or end.  Convert the
-                 * subpattern to lowercase.
-                 */
-                for (subi = 0;
-                    i < len && subi < sizeof(sub) - 1 && pattern[i] != ',';
-                    subi++, i++)
-                        sub[subi] = pattern[i];
-                /* If subpattern too long, return failure (no match). */
-                if (subi >= sizeof(sub) - 1)
-                        return 0;
-
-                /* If the subpattern was terminated by a comma, then skip it. */
-                if (i < len && pattern[i] == ',')
-                        i++;
-
-                /* Null-terminate the subpattern. */
-                sub[subi] = '\0';
-
-                /* Try to match the subpattern against the string. */
-                if (_match_pattern(string, sub, caseinsensitive)) {
-                        if (negated)
-                                return -1;              /* Negative */
-                        else
-                                got_positive = 1;       /* Positive */
-                }
-        }
-
-        /*
-         * Return success if got a positive match.  If there was a negative
-         * match, we have already returned -1 and never get here.
-         */
-        return got_positive;
-}
-
 #endif /* HAVE_CYGWIN */