[PATCH 2/3] Rename git-diff-tree-helper to git-diff-helper.

diff --git a/fsck-cache.c b/fsck-cache.c
index fb0d82f3320b7971d50d73893d777e3ddf1bd73b..a00702b79f7169ef3da7d60e9bbbe9ccf237e673 100644 (file)
--- a/fsck-cache.c
+++ b/fsck-cache.c
@@ -12,6 +12,7 @@
 static int show_root = 0;
 static int show_tags = 0;
 static int show_unreachable = 0;
+static int keep_cache_objects = 0; 
 static unsigned char head_sha1[20];
 
 static void check_connectivity(void)
@@ -61,6 +62,9 @@ static void check_connectivity(void)
  * So a directory called "a" is ordered _after_ a file
  * called "a.c", because "a/" sorts after "a.c".
  */
+#define TREE_UNORDERED (-1)
+#define TREE_HAS_DUPS  (-2)
+
 static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
 {
        int len1 = strlen(a->name);
@@ -73,7 +77,7 @@ static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
        if (cmp < 0)
                return 0;
        if (cmp > 0)
-               return -1;
+               return TREE_UNORDERED;
 
        /*
         * Ok, the first <len> characters are the same.
@@ -82,11 +86,18 @@ static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
         */
        c1 = a->name[len];
        c2 = b->name[len];
+       if (!c1 && !c2)
+               /*
+                * git-write-tree used to write out a nonsense tree that has
+                * entries with the same name, one blob and one tree.  Make
+                * sure we do not have duplicate entries.
+                */
+               return TREE_HAS_DUPS;
        if (!c1 && a->directory)
                c1 = '/';
        if (!c2 && b->directory)
                c2 = '/';
-       return c1 < c2 ? 0 : -1;
+       return c1 < c2 ? 0 : TREE_UNORDERED;
 }
 
 static int fsck_tree(struct tree *item)
@@ -99,11 +110,41 @@ static int fsck_tree(struct tree *item)
                if (strchr(entry->name, '/'))
                        has_full_path = 1;
 
+               switch (entry->mode) {
+               /*
+                * Standard modes.. 
+                */
+               case S_IFREG | 0755:
+               case S_IFREG | 0644:
+               case S_IFLNK:
+               case S_IFDIR:
+                       break;
+               /*
+                * This is nonstandard, but we had a few of these
+                * early on when we honored the full set of mode
+                * bits..
+                */
+               case S_IFREG | 0664:
+                       break;
+               default:
+                       printf("tree %s has entry %o %s\n",
+                               sha1_to_hex(item->object.sha1),
+                               entry->mode, entry->name);
+               }
+
                if (last) {
-                       if (verify_ordered(last, entry) < 0) {
+                       switch (verify_ordered(last, entry)) {
+                       case TREE_UNORDERED:
                                fprintf(stderr, "tree %s not ordered\n",
                                        sha1_to_hex(item->object.sha1));
                                return -1;
+                       case TREE_HAS_DUPS:
+                               fprintf(stderr, "tree %s has duplicate entries for '%s'\n",
+                                       sha1_to_hex(item->object.sha1),
+                                       entry->name);
+                               return -1;
+                       default:
+                               break;
                        }
                }
 
@@ -275,11 +316,15 @@ int main(int argc, char **argv)
                        show_root = 1;
                        continue;
                }
+               if (!strcmp(arg, "--cache")) {
+                       keep_cache_objects = 1;
+                       continue;
+               }
                if (*arg == '-')
-                       usage("fsck-cache [--tags] [[--unreachable] <head-sha1>*]");
+                       usage("fsck-cache [--tags] [[--unreachable] [--cache] <head-sha1>*]");
        }
 
-       sha1_dir = getenv(DB_ENVIRONMENT) ? : DEFAULT_DB_ENVIRONMENT;
+       sha1_dir = get_object_directory();
        for (i = 0; i < 256; i++) {
                static char dir[4096];
                sprintf(dir, "%s/%02x", sha1_dir, i);
@@ -295,14 +340,12 @@ int main(int argc, char **argv)
                        continue;
 
                if (!get_sha1(arg, head_sha1)) {
-                       struct commit *commit = lookup_commit(head_sha1);
-                       struct object *obj;
+                       struct object *obj = lookup_object(head_sha1);
 
-                       /* Error is printed by lookup_commit(). */
-                       if (!commit)
+                       /* Error is printed by lookup_object(). */
+                       if (!obj)
                                continue;
 
-                       obj = &commit->object;
                        obj->used = 1;
                        mark_reachable(obj, REACHABLE);
                        heads++;
@@ -311,12 +354,27 @@ int main(int argc, char **argv)
                error("expected sha1, got %s", arg);
        }
 
-       if (!heads) {
+       if (keep_cache_objects) {
+               int i;
+               read_cache();
+               for (i = 0; i < active_nr; i++) {
+                       struct blob *blob = lookup_blob(active_cache[i]->sha1);
+                       struct object *obj;
+                       if (!blob)
+                               continue;
+                       obj = &blob->object;
+                       obj->used = 1;
+                       mark_reachable(obj, REACHABLE);
+               }
+       }
+
+       if (!heads && !keep_cache_objects) {
                if (show_unreachable) {
-                       fprintf(stderr, "unable to do reachability without a head\n");
+                       fprintf(stderr, "unable to do reachability without a head nor --cache\n");
                        show_unreachable = 0; 
                }
-               fprintf(stderr, "expect dangling commits - potential heads - due to lack of head information\n");
+               if (!heads)
+                       fprintf(stderr, "expect dangling commits - potential heads - due to lack of head information\n");
        }
 
        check_connectivity();