Use symbolic constants for diff-raw status indicators.

Both Cogito and StGIT prefer to see 'A' for new files.  The
current 'N' is visually harder to distinguish from 'M', which is
used for modified files.  Prepare the internals to use symbolic
constants to make the change easier.

Signed-off-by: Junio C Hamano <junkio@cox.net>

diff --git a/diff-helper.c b/diff-helper.c
index 6649fb548f798c84342168b8ef9fe9211093fbfc..07ccd7cc38d02843d339a9feb21088912f63dcba 100644 (file)
--- a/diff-helper.c
+++ b/diff-helper.c
@@ -94,7 +94,8 @@ int main(int ac, const char **av) {
                        if (!strchr("MCRNDU", status))
                                break;
                        two_paths = score = 0;
-                       if (status == 'R' || status == 'C')
+                       if (status == DIFF_STATUS_RENAMED ||
+                           status == DIFF_STATUS_COPIED)
                                two_paths = 1;
 
                        /* pick up score if exists */

diff --git a/diff.c b/diff.c
index 3cb41c533313fdd70b3f13858c68032aeb08062a..4a4b62191284a2289631c01b3a2885387f59a8c0 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -617,7 +617,7 @@ static void run_diff(struct diff_filepair *p)
        other = (strcmp(name, p->two->path) ? p->two->path : NULL);
        one = p->one; two = p->two;
        switch (p->status) {
-       case 'C':
+       case DIFF_STATUS_COPIED:
                sprintf(msg_,
                        "similarity index %d%%\n"
                        "copy from %s\n"
@@ -626,7 +626,7 @@ static void run_diff(struct diff_filepair *p)
                        name, other);
                xfrm_msg = msg_;
                break;
-       case 'R':
+       case DIFF_STATUS_RENAMED:
                sprintf(msg_,
                        "similarity index %d%%\n"
                        "rename from %s\n"
@@ -635,7 +635,7 @@ static void run_diff(struct diff_filepair *p)
                        name, other);
                xfrm_msg = msg_;
                break;
-       case 'M':
+       case DIFF_STATUS_MODIFIED:
                if (p->score) {
                        sprintf(msg_,
                                "dissimilarity index %d%%",
@@ -796,10 +796,12 @@ static void diff_flush_raw(struct diff_filepair *p,
                status[1] = 0;
        }
        switch (p->status) {
-       case 'C': case 'R':
+       case DIFF_STATUS_COPIED:
+       case DIFF_STATUS_RENAMED:
                two_paths = 1;
                break;
-       case 'N': case 'D':
+       case DIFF_STATUS_ADDED:
+       case DIFF_STATUS_DELETED:
                two_paths = 0;
                break;
        default:
@@ -928,13 +930,13 @@ static void diff_resolve_rename_copy(void)
                p = q->queue[i];
                p->status = 0; /* undecided */
                if (DIFF_PAIR_UNMERGED(p))
-                       p->status = 'U';
+                       p->status = DIFF_STATUS_UNMERGED;
                else if (!DIFF_FILE_VALID(p->one))
-                       p->status = 'N';
+                       p->status = DIFF_STATUS_ADDED;
                else if (!DIFF_FILE_VALID(p->two))
-                       p->status = 'D';
+                       p->status = DIFF_STATUS_DELETED;
                else if (DIFF_PAIR_TYPE_CHANGED(p))
-                       p->status = 'T';
+                       p->status = DIFF_STATUS_TYPE_CHANGED;
 
                /* from this point on, we are dealing with a pair
                 * whose both sides are valid and of the same type, i.e.
@@ -942,7 +944,7 @@ static void diff_resolve_rename_copy(void)
                 */
                else if (DIFF_PAIR_RENAME(p)) {
                        if (p->source_stays) {
-                               p->status = 'C';
+                               p->status = DIFF_STATUS_COPIED;
                                continue;
                        }
                        /* See if there is some other filepair that
@@ -956,22 +958,22 @@ static void diff_resolve_rename_copy(void)
                                if (!DIFF_PAIR_RENAME(pp))
                                        continue; /* not a rename/copy */
                                /* pp is a rename/copy from the same source */
-                               p->status = 'C';
+                               p->status = DIFF_STATUS_COPIED;
                                break;
                        }
                        if (!p->status)
-                               p->status = 'R';
+                               p->status = DIFF_STATUS_RENAMED;
                }
                else if (memcmp(p->one->sha1, p->two->sha1, 20) ||
                         p->one->mode != p->two->mode)
-                       p->status = 'M';
+                       p->status = DIFF_STATUS_MODIFIED;
                else {
                        /* This is a "no-change" entry and should not
                         * happen anymore, but prepare for broken callers.
                         */
                        error("feeding unmodified %s to diffcore",
                              p->one->path);
-                       p->status = 'X';
+                       p->status = DIFF_STATUS_UNKNOWN;
                }
        }
        diff_debug_queue("resolve-rename-copy done", q);
@@ -989,7 +991,7 @@ void diff_flush(int diff_output_style, int line_termination)
        for (i = 0; i < q->nr; i++) {
                struct diff_filepair *p = q->queue[i];
                if ((diff_output_style == DIFF_FORMAT_NO_OUTPUT) ||
-                   (p->status == 'X'))
+                   (p->status == DIFF_STATUS_UNKNOWN))
                        continue;
                if (p->status == 0)
                        die("internal error in diff-resolve-rename-copy");
@@ -1024,15 +1026,17 @@ static void diffcore_apply_filter(const char *filter)
        if (!filter)
                return;
 
-       if (strchr(filter, 'A')) {
-               /* All-or-none */
+       if (strchr(filter, DIFF_STATUS_FILTER_AON)) {
                int found;
                for (i = found = 0; !found && i < q->nr; i++) {
                        struct diff_filepair *p = q->queue[i];
-                       if (((p->status == 'M') &&
-                            ((p->score && strchr(filter, 'B')) ||
-                             (!p->score && strchr(filter, 'M')))) ||
-                           ((p->status != 'M') && strchr(filter, p->status)))
+                       if (((p->status == DIFF_STATUS_MODIFIED) &&
+                            ((p->score &&
+                              strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
+                             (!p->score &&
+                              strchr(filter, DIFF_STATUS_MODIFIED)))) ||
+                           ((p->status != DIFF_STATUS_MODIFIED) &&
+                            strchr(filter, p->status)))
                                found++;
                }
                if (found)
@@ -1050,10 +1054,14 @@ static void diffcore_apply_filter(const char *filter)
                /* Only the matching ones */
                for (i = 0; i < q->nr; i++) {
                        struct diff_filepair *p = q->queue[i];
-                       if (((p->status == 'M') &&
-                            ((p->score && strchr(filter, 'B')) ||
-                             (!p->score && strchr(filter, 'M')))) ||
-                           ((p->status != 'M') && strchr(filter, p->status)))
+
+                       if (((p->status == DIFF_STATUS_MODIFIED) &&
+                            ((p->score &&
+                              strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
+                             (!p->score &&
+                              strchr(filter, DIFF_STATUS_MODIFIED)))) ||
+                           ((p->status != DIFF_STATUS_MODIFIED) &&
+                            strchr(filter, p->status)))
                                diff_q(&outq, p);
                        else
                                diff_free_filepair(p);

diff --git a/diff.h b/diff.h
index e0a3207a62eab9c72d74e3b15cfae660fbcdaa66..aebf3f1ab52c75e09e3a7da0a663cf12f68d197e 100644 (file)
--- a/diff.h
+++ b/diff.h
@@ -82,4 +82,20 @@ extern int diff_queue_is_empty(void);
 
 extern void diff_flush(int output_style, int line_terminator);
 
+/* diff-raw status letters */
+#define DIFF_STATUS_ADDED              'N'
+#define DIFF_STATUS_COPIED             'C'
+#define DIFF_STATUS_DELETED            'D'
+#define DIFF_STATUS_MODIFIED           'M'
+#define DIFF_STATUS_RENAMED            'R'
+#define DIFF_STATUS_TYPE_CHANGED       'T'
+#define DIFF_STATUS_UNKNOWN            'X'
+#define DIFF_STATUS_UNMERGED           'U'
+
+/* these are not diff-raw status letters proper, but used by
+ * diffcore-filter insn to specify additional restrictions.
+ */
+#define DIFF_STATUS_FILTER_AON         'A'
+#define DIFF_STATUS_FILTER_BROKEN      'B'
+
 #endif /* DIFF_H */