wildmatch: rename constants and update prototype

- All exported constants now have a prefix WM_
- Do not rely on FNM_* constants, use the WM_ counterparts
- Remove TRUE and FALSE to follow Git's coding style
- While at it, turn flags type from int to unsigned int
- Add an (unused yet) argument to carry extra information
so that we don't have to change the prototype again later
when we need to pass other stuff to wildmatch

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/dir.c b/dir.c
index cb7328b548a2eaf6ab1490354b9e9b6a560d327d..175a1827ba90966bbaa19931ef6e193762d4c7c6 100644 (file)
--- a/dir.c
+++ b/dir.c
@@ -595,7 +595,8 @@ int match_pathname(const char *pathname, int pathlen,
        }
 
        return wildmatch(pattern, name,
-                        ignore_case ? FNM_CASEFOLD : 0) == 0;
+                        ignore_case ? WM_CASEFOLD : 0,
+                        NULL) == 0;
 }
 
 /* Scan the list and let the last match determine the fate.

diff --git a/test-wildmatch.c b/test-wildmatch.c
index e384c8edb104c46c6cfe29677eccc8199fafe080..4bb23b4c92f5156dfeddaaf70e7c243518ce11e3 100644 (file)
--- a/test-wildmatch.c
+++ b/test-wildmatch.c
@@ -12,9 +12,9 @@ int main(int argc, char **argv)
                        argv[i] += 3;
        }
        if (!strcmp(argv[1], "wildmatch"))
-               return !!wildmatch(argv[3], argv[2], 0);
+               return !!wildmatch(argv[3], argv[2], 0, NULL);
        else if (!strcmp(argv[1], "iwildmatch"))
-               return !!wildmatch(argv[3], argv[2], FNM_CASEFOLD);
+               return !!wildmatch(argv[3], argv[2], WM_CASEFOLD, NULL);
        else if (!strcmp(argv[1], "fnmatch"))
                return !!fnmatch(argv[3], argv[2], FNM_PATHNAME);
        else

diff --git a/wildmatch.c b/wildmatch.c
index 2d3ed84364147d6d61252094566e7275d4c6aeb3..2a655fa7d4185471ea5ff791a1a441422ebd87f9 100644 (file)
--- a/wildmatch.c
+++ b/wildmatch.c
@@ -18,9 +18,6 @@ typedef unsigned char uchar;
 #define NEGATE_CLASS   '!'
 #define NEGATE_CLASS2  '^'
 
-#define FALSE 0
-#define TRUE 1
-
 #define CC_EQ(class, len, litmatch) ((len) == sizeof (litmatch)-1 \
                                    && *(class) == *(litmatch) \
                                    && strncmp((char*)class, litmatch, len) == 0)
@@ -64,7 +61,7 @@ static int dowild(const uchar *p, const uchar *text, int force_lower_case)
                int matched, match_slash, negated;
                uchar t_ch, prev_ch;
                if ((t_ch = *text) == '\0' && p_ch != '*')
-                       return ABORT_ALL;
+                       return WM_ABORT_ALL;
                if (force_lower_case && ISUPPER(t_ch))
                        t_ch = tolower(t_ch);
                if (force_lower_case && ISUPPER(p_ch))
@@ -77,12 +74,12 @@ static int dowild(const uchar *p, const uchar *text, int force_lower_case)
                        /* FALLTHROUGH */
                default:
                        if (t_ch != p_ch)
-                               return NOMATCH;
+                               return WM_NOMATCH;
                        continue;
                case '?':
                        /* Match anything but '/'. */
                        if (t_ch == '/')
-                               return NOMATCH;
+                               return WM_NOMATCH;
                        continue;
                case '*':
                        if (*++p == '*') {
@@ -101,135 +98,136 @@ static int dowild(const uchar *p, const uchar *text, int force_lower_case)
                                         * both foo/bar and foo/a/bar.
                                         */
                                        if (p[0] == '/' &&
-                                           dowild(p + 1, text, force_lower_case) == MATCH)
-                                               return MATCH;
-                                       match_slash = TRUE;
+                                           dowild(p + 1, text, force_lower_case) == WM_MATCH)
+                                               return WM_MATCH;
+                                       match_slash = 1;
                                } else
-                                       return ABORT_MALFORMED;
+                                       return WM_ABORT_MALFORMED;
                        } else
-                               match_slash = FALSE;
+                               match_slash = 0;
                        if (*p == '\0') {
                                /* Trailing "**" matches everything.  Trailing "*" matches
                                 * only if there are no more slash characters. */
                                if (!match_slash) {
                                        if (strchr((char*)text, '/') != NULL)
-                                               return NOMATCH;
+                                               return WM_NOMATCH;
                                }
-                               return MATCH;
+                               return WM_MATCH;
                        }
                        while (1) {
                                if (t_ch == '\0')
                                        break;
-                               if ((matched = dowild(p, text,  force_lower_case)) != NOMATCH) {
-                                       if (!match_slash || matched != ABORT_TO_STARSTAR)
+                               if ((matched = dowild(p, text,  force_lower_case)) != WM_NOMATCH) {
+                                       if (!match_slash || matched != WM_ABORT_TO_STARSTAR)
                                                return matched;
                                } else if (!match_slash && t_ch == '/')
-                                       return ABORT_TO_STARSTAR;
+                                       return WM_ABORT_TO_STARSTAR;
                                t_ch = *++text;
                        }
-                       return ABORT_ALL;
+                       return WM_ABORT_ALL;
                case '[':
                        p_ch = *++p;
 #ifdef NEGATE_CLASS2
                        if (p_ch == NEGATE_CLASS2)
                                p_ch = NEGATE_CLASS;
 #endif
-                       /* Assign literal TRUE/FALSE because of "matched" comparison. */
-                       negated = p_ch == NEGATE_CLASS? TRUE : FALSE;
+                       /* Assign literal 1/0 because of "matched" comparison. */
+                       negated = p_ch == NEGATE_CLASS ? 1 : 0;
                        if (negated) {
                                /* Inverted character class. */
                                p_ch = *++p;
                        }
                        prev_ch = 0;
-                       matched = FALSE;
+                       matched = 0;
                        do {
                                if (!p_ch)
-                                       return ABORT_ALL;
+                                       return WM_ABORT_ALL;
                                if (p_ch == '\\') {
                                        p_ch = *++p;
                                        if (!p_ch)
-                                               return ABORT_ALL;
+                                               return WM_ABORT_ALL;
                                        if (t_ch == p_ch)
-                                               matched = TRUE;
+                                               matched = 1;
                                } else if (p_ch == '-' && prev_ch && p[1] && p[1] != ']') {
                                        p_ch = *++p;
                                        if (p_ch == '\\') {
                                                p_ch = *++p;
                                                if (!p_ch)
-                                                       return ABORT_ALL;
+                                                       return WM_ABORT_ALL;
                                        }
                                        if (t_ch <= p_ch && t_ch >= prev_ch)
-                                               matched = TRUE;
+                                               matched = 1;
                                        p_ch = 0; /* This makes "prev_ch" get set to 0. */
                                } else if (p_ch == '[' && p[1] == ':') {
                                        const uchar *s;
                                        int i;
                                        for (s = p += 2; (p_ch = *p) && p_ch != ']'; p++) {} /*SHARED ITERATOR*/
                                        if (!p_ch)
-                                               return ABORT_ALL;
+                                               return WM_ABORT_ALL;
                                        i = p - s - 1;
                                        if (i < 0 || p[-1] != ':') {
                                                /* Didn't find ":]", so treat like a normal set. */
                                                p = s - 2;
                                                p_ch = '[';
                                                if (t_ch == p_ch)
-                                                       matched = TRUE;
+                                                       matched = 1;
                                                continue;
                                        }
                                        if (CC_EQ(s,i, "alnum")) {
                                                if (ISALNUM(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "alpha")) {
                                                if (ISALPHA(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "blank")) {
                                                if (ISBLANK(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "cntrl")) {
                                                if (ISCNTRL(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "digit")) {
                                                if (ISDIGIT(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "graph")) {
                                                if (ISGRAPH(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "lower")) {
                                                if (ISLOWER(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "print")) {
                                                if (ISPRINT(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "punct")) {
                                                if (ISPUNCT(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "space")) {
                                                if (ISSPACE(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "upper")) {
                                                if (ISUPPER(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else if (CC_EQ(s,i, "xdigit")) {
                                                if (ISXDIGIT(t_ch))
-                                                       matched = TRUE;
+                                                       matched = 1;
                                        } else /* malformed [:class:] string */
-                                               return ABORT_ALL;
+                                               return WM_ABORT_ALL;
                                        p_ch = 0; /* This makes "prev_ch" get set to 0. */
                                } else if (t_ch == p_ch)
-                                       matched = TRUE;
+                                       matched = 1;
                        } while (prev_ch = p_ch, (p_ch = *++p) != ']');
                        if (matched == negated || t_ch == '/')
-                               return NOMATCH;
+                               return WM_NOMATCH;
                        continue;
                }
        }
 
-       return *text ? NOMATCH : MATCH;
+       return *text ? WM_NOMATCH : WM_MATCH;
 }
 
 /* Match the "pattern" against the "text" string. */
-int wildmatch(const char *pattern, const char *text, int flags)
+int wildmatch(const char *pattern, const char *text,
+             unsigned int flags, struct wildopts *wo)
 {
        return dowild((const uchar*)pattern, (const uchar*)text,
-                     flags & FNM_CASEFOLD ? 1 :0);
+                     flags & WM_CASEFOLD ? 1 :0);
 }

diff --git a/wildmatch.h b/wildmatch.h
index 984a38cdc2a1a6d3b19816ccc0a45055a9c8508a..1c814fd5ff2fb1d08c62792950a44dbc5539a579 100644 (file)
--- a/wildmatch.h
+++ b/wildmatch.h
@@ -1,9 +1,17 @@
-/* wildmatch.h */
+#ifndef WILDMATCH_H
+#define WILDMATCH_H
 
-#define ABORT_MALFORMED 2
-#define NOMATCH 1
-#define MATCH 0
-#define ABORT_ALL -1
-#define ABORT_TO_STARSTAR -2
+#define WM_CASEFOLD 1
 
-int wildmatch(const char *pattern, const char *text, int flags);
+#define WM_ABORT_MALFORMED 2
+#define WM_NOMATCH 1
+#define WM_MATCH 0
+#define WM_ABORT_ALL -1
+#define WM_ABORT_TO_STARSTAR -2
+
+struct wildopts;
+
+int wildmatch(const char *pattern, const char *text,
+             unsigned int flags,
+             struct wildopts *wo);
+#endif