treewide: rename 'EXCL_FLAG_' to 'PATTERN_FLAG_'

The first consumer of pattern-matching filenames was the
.gitignore feature. In that context, storing a list of patterns
as a 'struct exclude_list'  makes sense. However, the
sparse-checkout feature then adopted these structures and methods,
but with the opposite meaning: these patterns match the files
that should be included!

It would be clearer to rename this entire library as a "pattern
matching" library, and the callers apply exclusion/inclusion
logic accordingly based on their needs.

This commit replaces 'EXCL_FLAG_' to 'PATTERN_FLAG_' in the
names of the flags used on 'struct path_pattern'.

Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/attr.c b/attr.c
index 93dc16b59cd6eff1d5c962ac2c4b01662948a93e..d90239869a894c4574dbc35bdee68e8a1caece96 100644 (file)
--- a/attr.c
+++ b/attr.c
@@ -259,7 +259,7 @@ struct pattern {
        const char *pattern;
        int patternlen;
        int nowildcardlen;
        const char *pattern;
        int patternlen;
        int nowildcardlen;

-       unsigned flags;         /* EXC_FLAG_* */
+       unsigned flags;         /* PATTERN_FLAG_* */

 };
 
 /*
 };
 
 /*


@@ -404,7 +404,7 @@ static struct match_attr *parse_attr_line(const char *line, const char *src,
                                      &res->u.pat.patternlen,
                                      &res->u.pat.flags,
                                      &res->u.pat.nowildcardlen);
                                      &res->u.pat.patternlen,
                                      &res->u.pat.flags,
                                      &res->u.pat.nowildcardlen);

-               if (res->u.pat.flags & EXC_FLAG_NEGATIVE) {
+               if (res->u.pat.flags & PATTERN_FLAG_NEGATIVE) {

                        warning(_("Negative patterns are ignored in git attributes\n"
                                  "Use '\\!' for literal leading exclamation."));
                        goto fail_return;
                        warning(_("Negative patterns are ignored in git attributes\n"
                                  "Use '\\!' for literal leading exclamation."));
                        goto fail_return;


@@ -991,10 +991,10 @@ static int path_matches(const char *pathname, int pathlen,
        int prefix = pat->nowildcardlen;
        int isdir = (pathlen && pathname[pathlen - 1] == '/');
 
        int prefix = pat->nowildcardlen;
        int isdir = (pathlen && pathname[pathlen - 1] == '/');
 

-       if ((pat->flags & EXC_FLAG_MUSTBEDIR) && !isdir)
+       if ((pat->flags & PATTERN_FLAG_MUSTBEDIR) && !isdir)

                return 0;
 
                return 0;
 

-       if (pat->flags & EXC_FLAG_NODIR) {
+       if (pat->flags & PATTERN_FLAG_NODIR) {

                return match_basename(pathname + basename_offset,
                                      pathlen - basename_offset - isdir,
                                      pattern, prefix,
                return match_basename(pathname + basename_offset,
                                      pathlen - basename_offset - isdir,
                                      pattern, prefix,

diff --git a/builtin/check-ignore.c b/builtin/check-ignore.c
index 97108ccb9ce2a3391737d723384ed8b89f7036bc..28b8f14999f506f68926d43f6c4e91046ef3c9ff 100644 (file)
--- a/builtin/check-ignore.c
+++ b/builtin/check-ignore.c
@@ -34,8 +34,8 @@ static const struct option check_ignore_options[] = {
 
 static void output_pattern(const char *path, struct path_pattern *pattern)
 {
 
 static void output_pattern(const char *path, struct path_pattern *pattern)
 {

-       char *bang  = (pattern && pattern->flags & EXC_FLAG_NEGATIVE)  ? "!" : "";
-       char *slash = (pattern && pattern->flags & EXC_FLAG_MUSTBEDIR) ? "/" : "";
+       char *bang  = (pattern && pattern->flags & PATTERN_FLAG_NEGATIVE)  ? "!" : "";
+       char *slash = (pattern && pattern->flags & PATTERN_FLAG_MUSTBEDIR) ? "/" : "";

        if (!nul_term_line) {
                if (!verbose) {
                        write_name_quoted(path, stdout, '\n');
        if (!nul_term_line) {
                if (!verbose) {
                        write_name_quoted(path, stdout, '\n');

diff --git a/dir.c b/dir.c
index b522d61ee0ca6f8e6433fdfd7809296b3dfbfbcf..640f10973e2d7a09b333f969f15a6cba5f1d7494 100644 (file)
--- a/dir.c
+++ b/dir.c
@@ -571,20 +571,20 @@ void parse_exclude_pattern(const char **pattern,
 
        *flags = 0;
        if (*p == '!') {
 
        *flags = 0;
        if (*p == '!') {

-               *flags |= EXC_FLAG_NEGATIVE;
+               *flags |= PATTERN_FLAG_NEGATIVE;

                p++;
        }
        len = strlen(p);
        if (len && p[len - 1] == '/') {
                len--;
                p++;
        }
        len = strlen(p);
        if (len && p[len - 1] == '/') {
                len--;

-               *flags |= EXC_FLAG_MUSTBEDIR;
+               *flags |= PATTERN_FLAG_MUSTBEDIR;

        }
        for (i = 0; i < len; i++) {
                if (p[i] == '/')
                        break;
        }
        if (i == len)
        }
        for (i = 0; i < len; i++) {
                if (p[i] == '/')
                        break;
        }
        if (i == len)

-               *flags |= EXC_FLAG_NODIR;
+               *flags |= PATTERN_FLAG_NODIR;

        *nowildcardlen = simple_length(p);
        /*
         * we should have excluded the trailing slash from 'p' too,
        *nowildcardlen = simple_length(p);
        /*
         * we should have excluded the trailing slash from 'p' too,


@@ -594,7 +594,7 @@ void parse_exclude_pattern(const char **pattern,
        if (*nowildcardlen > len)
                *nowildcardlen = len;
        if (*p == '*' && no_wildcard(p + 1))
        if (*nowildcardlen > len)
                *nowildcardlen = len;
        if (*p == '*' && no_wildcard(p + 1))

-               *flags |= EXC_FLAG_ENDSWITH;
+               *flags |= PATTERN_FLAG_ENDSWITH;

        *pattern = p;
        *patternlen = len;
 }
        *pattern = p;
        *patternlen = len;
 }


@@ -608,7 +608,7 @@ void add_exclude(const char *string, const char *base,
        int nowildcardlen;
 
        parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);
        int nowildcardlen;
 
        parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);

-       if (flags & EXC_FLAG_MUSTBEDIR) {
+       if (flags & PATTERN_FLAG_MUSTBEDIR) {

                FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen);
        } else {
                pattern = xmalloc(sizeof(*pattern));
                FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen);
        } else {
                pattern = xmalloc(sizeof(*pattern));


@@ -940,7 +940,7 @@ int match_basename(const char *basename, int basenamelen,
                if (patternlen == basenamelen &&
                    !fspathncmp(pattern, basename, basenamelen))
                        return 1;
                if (patternlen == basenamelen &&
                    !fspathncmp(pattern, basename, basenamelen))
                        return 1;

-       } else if (flags & EXC_FLAG_ENDSWITH) {
+       } else if (flags & PATTERN_FLAG_ENDSWITH) {

                /* "*literal" matching against "fooliteral" */
                if (patternlen - 1 <= basenamelen &&
                    !fspathncmp(pattern + 1,
                /* "*literal" matching against "fooliteral" */
                if (patternlen - 1 <= basenamelen &&
                    !fspathncmp(pattern + 1,


@@ -1039,14 +1039,14 @@ static struct path_pattern *last_exclude_matching_from_list(const char *pathname
                const char *exclude = pattern->pattern;
                int prefix = pattern->nowildcardlen;
 
                const char *exclude = pattern->pattern;
                int prefix = pattern->nowildcardlen;
 

-               if (pattern->flags & EXC_FLAG_MUSTBEDIR) {
+               if (pattern->flags & PATTERN_FLAG_MUSTBEDIR) {

                        if (*dtype == DT_UNKNOWN)
                                *dtype = get_dtype(NULL, istate, pathname, pathlen);
                        if (*dtype != DT_DIR)
                                continue;
                }
 
                        if (*dtype == DT_UNKNOWN)
                                *dtype = get_dtype(NULL, istate, pathname, pathlen);
                        if (*dtype != DT_DIR)
                                continue;
                }
 

-               if (pattern->flags & EXC_FLAG_NODIR) {
+               if (pattern->flags & PATTERN_FLAG_NODIR) {

                        if (match_basename(basename,
                                           pathlen - (basename - pathname),
                                           exclude, prefix, pattern->patternlen,
                        if (match_basename(basename,
                                           pathlen - (basename - pathname),
                                           exclude, prefix, pattern->patternlen,


@@ -1083,7 +1083,7 @@ int is_excluded_from_list(const char *pathname,
        pattern = last_exclude_matching_from_list(pathname, pathlen, basename,
                                                  dtype, pl, istate);
        if (pattern)
        pattern = last_exclude_matching_from_list(pathname, pathlen, basename,
                                                  dtype, pl, istate);
        if (pattern)

-               return pattern->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
+               return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;

        return -1; /* undecided */
 }
 
        return -1; /* undecided */
 }
 


@@ -1198,7 +1198,7 @@ static void prep_exclude(struct dir_struct *dir,
                                dir->basebuf.buf + current, &dt);
                        dir->basebuf.buf[stk->baselen - 1] = '/';
                        if (dir->pattern &&
                                dir->basebuf.buf + current, &dt);
                        dir->basebuf.buf[stk->baselen - 1] = '/';
                        if (dir->pattern &&

-                           dir->pattern->flags & EXC_FLAG_NEGATIVE)
+                           dir->pattern->flags & PATTERN_FLAG_NEGATIVE)

                                dir->pattern = NULL;
                        if (dir->pattern) {
                                dir->exclude_stack = stk;
                                dir->pattern = NULL;
                        if (dir->pattern) {
                                dir->exclude_stack = stk;


@@ -1298,7 +1298,7 @@ int is_excluded(struct dir_struct *dir, struct index_state *istate,
        struct path_pattern *pattern =
                last_exclude_matching(dir, istate, pathname, dtype_p);
        if (pattern)
        struct path_pattern *pattern =
                last_exclude_matching(dir, istate, pathname, dtype_p);
        if (pattern)

-               return pattern->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
+               return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;

        return 0;
 }
 
        return 0;
 }
 

diff --git a/dir.h b/dir.h
index 4114d6bf784225f39d05a1a455a08496145468c8..87eb10662f5639ec618240cb542ef2164af85814 100644 (file)
--- a/dir.h
+++ b/dir.h
@@ -11,10 +11,10 @@ struct dir_entry {
        char name[FLEX_ARRAY]; /* more */
 };
 
        char name[FLEX_ARRAY]; /* more */
 };
 

-#define EXC_FLAG_NODIR 1
-#define EXC_FLAG_ENDSWITH 4
-#define EXC_FLAG_MUSTBEDIR 8
-#define EXC_FLAG_NEGATIVE 16
+#define PATTERN_FLAG_NODIR 1
+#define PATTERN_FLAG_ENDSWITH 4
+#define PATTERN_FLAG_MUSTBEDIR 8
+#define PATTERN_FLAG_NEGATIVE 16

 
 struct path_pattern {
        /*
 
 struct path_pattern {
        /*


@@ -28,7 +28,7 @@ struct path_pattern {
        int nowildcardlen;
        const char *base;
        int baselen;
        int nowildcardlen;
        const char *base;
        int baselen;

-       unsigned flags;         /* EXC_FLAG_* */
+       unsigned flags;         /* PATTERN_FLAG_* */

 
        /*
         * Counting starts from 1 for line numbers in ignore files,
 
        /*
         * Counting starts from 1 for line numbers in ignore files,