wildmatch: follow Git's coding convention

wildmatch's coding style is pretty close to Git's except the use of 4
space indentation instead of 8. This patch should produce empty diff
with "git diff -b"

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/wildmatch.c b/wildmatch.c
index fae73976ebc33f50d6ae27c52cc874a3b024181d..4653dd6eb8a810f31ecc82c3f2347c9693355d65 100644 (file)
--- a/wildmatch.c
+++ b/wildmatch.c
@@ -58,167 +58,167 @@ static int force_lower_case = 0;
 /* Match pattern "p" against "text" */
 static int dowild(const uchar *p, const uchar *text)
 {
-    uchar p_ch;
+       uchar p_ch;
 
-    for ( ; (p_ch = *p) != '\0'; text++, p++) {
-       int matched, special;
-       uchar t_ch, prev_ch;
-       if ((t_ch = *text) == '\0' && p_ch != '*')
-               return ABORT_ALL;
-       if (force_lower_case && ISUPPER(t_ch))
-           t_ch = tolower(t_ch);
-       switch (p_ch) {
-         case '\\':
-           /* Literal match with following character.  Note that the test
-            * in "default" handles the p[1] == '\0' failure case. */
-           p_ch = *++p;
-           /* FALLTHROUGH */
-         default:
-           if (t_ch != p_ch)
-               return FALSE;
-           continue;
-         case '?':
-           /* Match anything but '/'. */
-           if (t_ch == '/')
-               return FALSE;
-           continue;
-         case '*':
-           if (*++p == '*') {
-               while (*++p == '*') {}
-               special = TRUE;
-           } else
-               special = FALSE;
-           if (*p == '\0') {
-               /* Trailing "**" matches everything.  Trailing "*" matches
-                * only if there are no more slash characters. */
-               if (!special) {
-                       if (strchr((char*)text, '/') != NULL)
-                           return FALSE;
-               }
-               return TRUE;
-           }
-           while (1) {
-               if (t_ch == '\0')
-                   break;
-               if ((matched = dowild(p, text)) != FALSE) {
-                   if (!special || matched != ABORT_TO_STARSTAR)
-                       return matched;
-               } else if (!special && t_ch == '/')
-                   return ABORT_TO_STARSTAR;
-               t_ch = *++text;
-           }
-           return 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. */
-           special = p_ch == NEGATE_CLASS? TRUE : FALSE;
-           if (special) {
-               /* Inverted character class. */
-               p_ch = *++p;
-           }
-           prev_ch = 0;
-           matched = FALSE;
-           do {
-               if (!p_ch)
-                   return ABORT_ALL;
-               if (p_ch == '\\') {
-                   p_ch = *++p;
-                   if (!p_ch)
+       for ( ; (p_ch = *p) != '\0'; text++, p++) {
+               int matched, special;
+               uchar t_ch, prev_ch;
+               if ((t_ch = *text) == '\0' && p_ch != '*')
                        return ABORT_ALL;
-                   if (t_ch == p_ch)
-                       matched = TRUE;
-               } else if (p_ch == '-' && prev_ch && p[1] && p[1] != ']') {
-                   p_ch = *++p;
-                   if (p_ch == '\\') {
+               if (force_lower_case && ISUPPER(t_ch))
+                       t_ch = tolower(t_ch);
+               switch (p_ch) {
+               case '\\':
+                       /* Literal match with following character.  Note that the test
+                        * in "default" handles the p[1] == '\0' failure case. */
                        p_ch = *++p;
-                       if (!p_ch)
-                           return ABORT_ALL;
-                   }
-                   if (t_ch <= p_ch && t_ch >= prev_ch)
-                       matched = TRUE;
-                   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;
-                   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;
+                       /* FALLTHROUGH */
+               default:
+                       if (t_ch != p_ch)
+                               return FALSE;
+                       continue;
+               case '?':
+                       /* Match anything but '/'. */
+                       if (t_ch == '/')
+                               return FALSE;
                        continue;
-                   }
-                   if (CC_EQ(s,i, "alnum")) {
-                       if (ISALNUM(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "alpha")) {
-                       if (ISALPHA(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "blank")) {
-                       if (ISBLANK(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "cntrl")) {
-                       if (ISCNTRL(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "digit")) {
-                       if (ISDIGIT(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "graph")) {
-                       if (ISGRAPH(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "lower")) {
-                       if (ISLOWER(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "print")) {
-                       if (ISPRINT(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "punct")) {
-                       if (ISPUNCT(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "space")) {
-                       if (ISSPACE(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "upper")) {
-                       if (ISUPPER(t_ch))
-                           matched = TRUE;
-                   } else if (CC_EQ(s,i, "xdigit")) {
-                       if (ISXDIGIT(t_ch))
-                           matched = TRUE;
-                   } else /* malformed [:class:] string */
+               case '*':
+                       if (*++p == '*') {
+                               while (*++p == '*') {}
+                               special = TRUE;
+                       } else
+                               special = FALSE;
+                       if (*p == '\0') {
+                               /* Trailing "**" matches everything.  Trailing "*" matches
+                                * only if there are no more slash characters. */
+                               if (!special) {
+                                       if (strchr((char*)text, '/') != NULL)
+                                               return FALSE;
+                               }
+                               return TRUE;
+                       }
+                       while (1) {
+                               if (t_ch == '\0')
+                                       break;
+                               if ((matched = dowild(p, text)) != FALSE) {
+                                       if (!special || matched != ABORT_TO_STARSTAR)
+                                               return matched;
+                               } else if (!special && t_ch == '/')
+                                       return ABORT_TO_STARSTAR;
+                               t_ch = *++text;
+                       }
                        return ABORT_ALL;
-                   p_ch = 0; /* This makes "prev_ch" get set to 0. */
-               } else if (t_ch == p_ch)
-                   matched = TRUE;
-           } while (prev_ch = p_ch, (p_ch = *++p) != ']');
-           if (matched == special || t_ch == '/')
-               return FALSE;
-           continue;
+               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. */
+                       special = p_ch == NEGATE_CLASS? TRUE : FALSE;
+                       if (special) {
+                               /* Inverted character class. */
+                               p_ch = *++p;
+                       }
+                       prev_ch = 0;
+                       matched = FALSE;
+                       do {
+                               if (!p_ch)
+                                       return ABORT_ALL;
+                               if (p_ch == '\\') {
+                                       p_ch = *++p;
+                                       if (!p_ch)
+                                               return ABORT_ALL;
+                                       if (t_ch == p_ch)
+                                               matched = TRUE;
+                               } 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;
+                                       }
+                                       if (t_ch <= p_ch && t_ch >= prev_ch)
+                                               matched = TRUE;
+                                       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;
+                                       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;
+                                               continue;
+                                       }
+                                       if (CC_EQ(s,i, "alnum")) {
+                                               if (ISALNUM(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "alpha")) {
+                                               if (ISALPHA(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "blank")) {
+                                               if (ISBLANK(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "cntrl")) {
+                                               if (ISCNTRL(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "digit")) {
+                                               if (ISDIGIT(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "graph")) {
+                                               if (ISGRAPH(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "lower")) {
+                                               if (ISLOWER(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "print")) {
+                                               if (ISPRINT(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "punct")) {
+                                               if (ISPUNCT(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "space")) {
+                                               if (ISSPACE(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "upper")) {
+                                               if (ISUPPER(t_ch))
+                                                       matched = TRUE;
+                                       } else if (CC_EQ(s,i, "xdigit")) {
+                                               if (ISXDIGIT(t_ch))
+                                                       matched = TRUE;
+                                       } else /* malformed [:class:] string */
+                                               return ABORT_ALL;
+                                       p_ch = 0; /* This makes "prev_ch" get set to 0. */
+                               } else if (t_ch == p_ch)
+                                       matched = TRUE;
+                       } while (prev_ch = p_ch, (p_ch = *++p) != ']');
+                       if (matched == special || t_ch == '/')
+                               return FALSE;
+                       continue;
+               }
        }
-    }
 
-    return *text ? FALSE : TRUE;
+       return *text ? FALSE : TRUE;
 }
 
 /* Match the "pattern" against the "text" string. */
 int wildmatch(const char *pattern, const char *text)
 {
-    return dowild((const uchar*)pattern, (const uchar*)text) == TRUE;
+       return dowild((const uchar*)pattern, (const uchar*)text) == TRUE;
 }
 
 /* Match the "pattern" against the forced-to-lower-case "text" string. */
 int iwildmatch(const char *pattern, const char *text)
 {
-    int ret;
-    force_lower_case = 1;
-    ret = dowild((const uchar*)pattern, (const uchar*)text) == TRUE;
-    force_lower_case = 0;
-    return ret;
+       int ret;
+       force_lower_case = 1;
+       ret = dowild((const uchar*)pattern, (const uchar*)text) == TRUE;
+       force_lower_case = 0;
+       return ret;
 }