diff-cache.con commit [PATCH] Add -k kill keyword expansion option to git-cvsimport - revised (abe0582)
   1#include "cache.h"
   2#include "diff.h"
   3
   4static int cached_only = 0;
   5static int diff_output_format = DIFF_FORMAT_RAW;
   6static int diff_line_termination = '\n';
   7static int match_nonexisting = 0;
   8static int detect_rename = 0;
   9static int find_copies_harder = 0;
  10static int diff_setup_opt = 0;
  11static int diff_score_opt = 0;
  12static const char *pickaxe = NULL;
  13static int pickaxe_opts = 0;
  14static int diff_break_opt = -1;
  15static const char *orderfile = NULL;
  16static const char *diff_filter = NULL;
  17
  18/* A file entry went away or appeared */
  19static void show_file(const char *prefix, struct cache_entry *ce, unsigned char *sha1, unsigned int mode)
  20{
  21        diff_addremove(prefix[0], ntohl(mode), sha1, ce->name, NULL);
  22}
  23
  24static int get_stat_data(struct cache_entry *ce, unsigned char **sha1p, unsigned int *modep)
  25{
  26        unsigned char *sha1 = ce->sha1;
  27        unsigned int mode = ce->ce_mode;
  28
  29        if (!cached_only) {
  30                static unsigned char no_sha1[20];
  31                int changed;
  32                struct stat st;
  33                if (lstat(ce->name, &st) < 0) {
  34                        if (errno == ENOENT && match_nonexisting) {
  35                                *sha1p = sha1;
  36                                *modep = mode;
  37                                return 0;
  38                        }
  39                        return -1;
  40                }
  41                changed = ce_match_stat(ce, &st);
  42                if (changed) {
  43                        mode = create_ce_mode(st.st_mode);
  44                        sha1 = no_sha1;
  45                }
  46        }
  47
  48        *sha1p = sha1;
  49        *modep = mode;
  50        return 0;
  51}
  52
  53static void show_new_file(struct cache_entry *new)
  54{
  55        unsigned char *sha1;
  56        unsigned int mode;
  57
  58        /* New file in the index: it might actually be different in the working copy */
  59        if (get_stat_data(new, &sha1, &mode) < 0)
  60                return;
  61
  62        show_file("+", new, sha1, mode);
  63}
  64
  65static int show_modified(struct cache_entry *old,
  66                         struct cache_entry *new,
  67                         int report_missing)
  68{
  69        unsigned int mode, oldmode;
  70        unsigned char *sha1;
  71
  72        if (get_stat_data(new, &sha1, &mode) < 0) {
  73                if (report_missing)
  74                        show_file("-", old, old->sha1, old->ce_mode);
  75                return -1;
  76        }
  77
  78        oldmode = old->ce_mode;
  79        if (mode == oldmode && !memcmp(sha1, old->sha1, 20) &&
  80            !find_copies_harder)
  81                return 0;
  82
  83        mode = ntohl(mode);
  84        oldmode = ntohl(oldmode);
  85
  86        diff_change(oldmode, mode,
  87                    old->sha1, sha1, old->name, NULL);
  88        return 0;
  89}
  90
  91static int diff_cache(struct cache_entry **ac, int entries, const char **pathspec)
  92{
  93        while (entries) {
  94                struct cache_entry *ce = *ac;
  95                int same = (entries > 1) && ce_same_name(ce, ac[1]);
  96
  97                if (!ce_path_match(ce, pathspec))
  98                        goto skip_entry;
  99
 100                switch (ce_stage(ce)) {
 101                case 0:
 102                        /* No stage 1 entry? That means it's a new file */
 103                        if (!same) {
 104                                show_new_file(ce);
 105                                break;
 106                        }
 107                        /* Show difference between old and new */
 108                        show_modified(ac[1], ce, 1);
 109                        break;
 110                case 1:
 111                        /* No stage 3 (merge) entry? That means it's been deleted */
 112                        if (!same) {
 113                                show_file("-", ce, ce->sha1, ce->ce_mode);
 114                                break;
 115                        }
 116                        /* We come here with ce pointing at stage 1
 117                         * (original tree) and ac[1] pointing at stage
 118                         * 3 (unmerged).  show-modified with
 119                         * report-mising set to false does not say the
 120                         * file is deleted but reports true if work
 121                         * tree does not have it, in which case we
 122                         * fall through to report the unmerged state.
 123                         * Otherwise, we show the differences between
 124                         * the original tree and the work tree.
 125                         */
 126                        if (!cached_only && !show_modified(ce, ac[1], 0))
 127                                break;
 128                        /* fallthru */
 129                case 3:
 130                        diff_unmerge(ce->name);
 131                        break;
 132
 133                default:
 134                        die("impossible cache entry stage");
 135                }
 136
 137skip_entry:
 138                /*
 139                 * Ignore all the different stages for this file,
 140                 * we've handled the relevant cases now.
 141                 */
 142                do {
 143                        ac++;
 144                        entries--;
 145                } while (entries && ce_same_name(ce, ac[0]));
 146        }
 147        return 0;
 148}
 149
 150/*
 151 * This turns all merge entries into "stage 3". That guarantees that
 152 * when we read in the new tree (into "stage 1"), we won't lose sight
 153 * of the fact that we had unmerged entries.
 154 */
 155static void mark_merge_entries(void)
 156{
 157        int i;
 158        for (i = 0; i < active_nr; i++) {
 159                struct cache_entry *ce = active_cache[i];
 160                if (!ce_stage(ce))
 161                        continue;
 162                ce->ce_flags |= htons(CE_STAGEMASK);
 163        }
 164}
 165
 166static const char diff_cache_usage[] =
 167"git-diff-cache [-m] [--cached] "
 168"[<common diff options>] <tree-ish> [<path>...]"
 169COMMON_DIFF_OPTIONS_HELP;
 170
 171int main(int argc, const char **argv)
 172{
 173        const char *tree_name = NULL;
 174        unsigned char sha1[20];
 175        const char **pathspec = NULL;
 176        void *tree;
 177        unsigned long size;
 178        int ret;
 179        int allow_options = 1;
 180        int i;
 181
 182        read_cache();
 183        for (i = 1; i < argc; i++) {
 184                const char *arg = argv[i];
 185
 186                if (!allow_options || *arg != '-') {
 187                        if (tree_name) {
 188                                pathspec = argv + i;
 189                                break;
 190                        }
 191                        tree_name = arg;
 192                        continue;
 193                }
 194                        
 195                if (!strcmp(arg, "--")) {
 196                        allow_options = 0;
 197                        continue;
 198                }
 199                if (!strcmp(arg, "-r")) {
 200                        /* We accept the -r flag just to look like git-diff-tree */
 201                        continue;
 202                }
 203                /* We accept the -u flag as a synonym for "-p" */
 204                if (!strcmp(arg, "-p") || !strcmp(arg, "-u")) {
 205                        diff_output_format = DIFF_FORMAT_PATCH;
 206                        continue;
 207                }
 208                if (!strncmp(arg, "-B", 2)) {
 209                        if ((diff_break_opt = diff_scoreopt_parse(arg)) == -1)
 210                                usage(diff_cache_usage);
 211                        continue;
 212                }
 213                if (!strncmp(arg, "-M", 2)) {
 214                        detect_rename = DIFF_DETECT_RENAME;
 215                        if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1)
 216                                usage(diff_cache_usage);
 217                        continue;
 218                }
 219                if (!strncmp(arg, "-C", 2)) {
 220                        detect_rename = DIFF_DETECT_COPY;
 221                        if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1)
 222                                usage(diff_cache_usage);
 223                        continue;
 224                }
 225                if (!strcmp(arg, "--find-copies-harder")) {
 226                        find_copies_harder = 1;
 227                        continue;
 228                }
 229                if (!strcmp(arg, "-z")) {
 230                        diff_line_termination = 0;
 231                        continue;
 232                }
 233                if (!strcmp(arg, "--name-only")) {
 234                        diff_output_format = DIFF_FORMAT_NAME;
 235                        continue;
 236                }
 237                if (!strcmp(arg, "-R")) {
 238                        diff_setup_opt |= DIFF_SETUP_REVERSE;
 239                        continue;
 240                }
 241                if (!strncmp(arg, "-S", 2)) {
 242                        pickaxe = arg + 2;
 243                        continue;
 244                }
 245                if (!strncmp(arg, "--diff-filter=", 14)) {
 246                        diff_filter = arg + 14;
 247                        continue;
 248                }
 249                if (!strncmp(arg, "-O", 2)) {
 250                        orderfile = arg + 2;
 251                        continue;
 252                }
 253                if (!strcmp(arg, "--pickaxe-all")) {
 254                        pickaxe_opts = DIFF_PICKAXE_ALL;
 255                        continue;
 256                }
 257                if (!strcmp(arg, "-m")) {
 258                        match_nonexisting = 1;
 259                        continue;
 260                }
 261                if (!strcmp(arg, "--cached")) {
 262                        cached_only = 1;
 263                        continue;
 264                }
 265                usage(diff_cache_usage);
 266        }
 267
 268        if (find_copies_harder && detect_rename != DIFF_DETECT_COPY)
 269                usage(diff_cache_usage);
 270
 271        if (!tree_name || get_sha1(tree_name, sha1))
 272                usage(diff_cache_usage);
 273
 274        /* The rest is for paths restriction. */
 275        diff_setup(diff_setup_opt);
 276
 277        mark_merge_entries();
 278
 279        tree = read_object_with_reference(sha1, "tree", &size, NULL);
 280        if (!tree)
 281                die("bad tree object %s", tree_name);
 282        if (read_tree(tree, size, 1, pathspec))
 283                die("unable to read tree object %s", tree_name);
 284
 285        ret = diff_cache(active_cache, active_nr, pathspec);
 286
 287        diffcore_std(pathspec,
 288                     detect_rename, diff_score_opt,
 289                     pickaxe, pickaxe_opts,
 290                     diff_break_opt,
 291                     orderfile, diff_filter);
 292        diff_flush(diff_output_format, diff_line_termination);
 293        return ret;
 294}