t4013: add tests for diff/log family output options.
[gitweb.git] / fsck-objects.c
index 1922b6d84c51588b22553141f608c9a07182560b..769bb2a6a75f34192cfd7d6f99ea8f6efbfdce7e 100644 (file)
@@ -9,8 +9,10 @@
 #include "refs.h"
 #include "pack.h"
 #include "cache-tree.h"
+#include "tree-walk.h"
 
 #define REACHABLE 0x0001
+#define SEEN      0x0002
 
 static int show_root = 0;
 static int show_tags = 0;
@@ -32,7 +34,7 @@ static void objreport(struct object *obj, const char *severity,
                       const char *err, va_list params)
 {
        fprintf(stderr, "%s in %s %s: ",
-               severity, obj->type, sha1_to_hex(obj->sha1));
+               severity, typename(obj->type), sha1_to_hex(obj->sha1));
        vfprintf(stderr, err, params);
        fputs("\n", stderr);
 }
@@ -62,6 +64,7 @@ static void check_connectivity(void)
 
        /* Look up all the requirements, warn about missing objects.. */
        for (i = 0; i < obj_allocs; i++) {
+               const struct object_refs *refs;
                struct object *obj = objs[i];
 
                if (!obj)
@@ -72,12 +75,12 @@ static void check_connectivity(void)
                                ; /* it is in pack */
                        else
                                printf("missing %s %s\n",
-                                      obj->type, sha1_to_hex(obj->sha1));
+                                      typename(obj->type), sha1_to_hex(obj->sha1));
                        continue;
                }
 
-               if (obj->refs) {
-                       const struct object_refs *refs = obj->refs;
+               refs = lookup_object_refs(obj);
+               if (refs) {
                        unsigned j;
                        for (j = 0; j < refs->count; j++) {
                                struct object *ref = refs->ref[j];
@@ -85,20 +88,20 @@ static void check_connectivity(void)
                                    (has_sha1_file(ref->sha1)))
                                        continue;
                                printf("broken link from %7s %s\n",
-                                      obj->type, sha1_to_hex(obj->sha1));
+                                      typename(obj->type), sha1_to_hex(obj->sha1));
                                printf("              to %7s %s\n",
-                                      ref->type, sha1_to_hex(ref->sha1));
+                                      typename(ref->type), sha1_to_hex(ref->sha1));
                        }
                }
 
                if (show_unreachable && !(obj->flags & REACHABLE)) {
                        printf("unreachable %s %s\n",
-                              obj->type, sha1_to_hex(obj->sha1));
+                              typename(obj->type), sha1_to_hex(obj->sha1));
                        continue;
                }
 
                if (!obj->used) {
-                       printf("dangling %s %s\n", obj->type, 
+                       printf("dangling %s %s\n", typename(obj->type),
                               sha1_to_hex(obj->sha1));
                }
        }
@@ -115,15 +118,15 @@ static void check_connectivity(void)
 #define TREE_UNORDERED (-1)
 #define TREE_HAS_DUPS  (-2)
 
-static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
+static int verify_ordered(unsigned mode1, const char *name1, unsigned mode2, const char *name2)
 {
-       int len1 = strlen(a->name);
-       int len2 = strlen(b->name);
+       int len1 = strlen(name1);
+       int len2 = strlen(name2);
        int len = len1 < len2 ? len1 : len2;
        unsigned char c1, c2;
        int cmp;
 
-       cmp = memcmp(a->name, b->name, len);
+       cmp = memcmp(name1, name2, len);
        if (cmp < 0)
                return 0;
        if (cmp > 0)
@@ -134,8 +137,8 @@ static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
         * Now we need to order the next one, but turn
         * a '\0' into a '/' for a directory entry.
         */
-       c1 = a->name[len];
-       c2 = b->name[len];
+       c1 = name1[len];
+       c2 = name2[len];
        if (!c1 && !c2)
                /*
                 * git-write-tree used to write out a nonsense tree that has
@@ -143,9 +146,9 @@ static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
                 * sure we do not have duplicate entries.
                 */
                return TREE_HAS_DUPS;
-       if (!c1 && a->directory)
+       if (!c1 && S_ISDIR(mode1))
                c1 = '/';
-       if (!c2 && b->directory)
+       if (!c2 && S_ISDIR(mode2))
                c2 = '/';
        return c1 < c2 ? 0 : TREE_UNORDERED;
 }
@@ -158,17 +161,32 @@ static int fsck_tree(struct tree *item)
        int has_bad_modes = 0;
        int has_dup_entries = 0;
        int not_properly_sorted = 0;
-       struct tree_entry_list *entry, *last;
+       struct tree_desc desc;
+       unsigned o_mode;
+       const char *o_name;
+       const unsigned char *o_sha1;
 
-       last = NULL;
-       for (entry = item->entries; entry; entry = entry->next) {
-               if (strchr(entry->name, '/'))
+       desc.buf = item->buffer;
+       desc.size = item->size;
+
+       o_mode = 0;
+       o_name = NULL;
+       o_sha1 = NULL;
+       while (desc.size) {
+               unsigned mode;
+               const char *name;
+               const unsigned char *sha1;
+
+               sha1 = tree_entry_extract(&desc, &name, &mode);
+
+               if (strchr(name, '/'))
                        has_full_path = 1;
-               has_zero_pad |= entry->zeropad;
+               has_zero_pad |= *(char *)desc.buf == '0';
+               update_tree_entry(&desc);
 
-               switch (entry->mode) {
+               switch (mode) {
                /*
-                * Standard modes.. 
+                * Standard modes..
                 */
                case S_IFREG | 0755:
                case S_IFREG | 0644:
@@ -187,8 +205,8 @@ static int fsck_tree(struct tree *item)
                        has_bad_modes = 1;
                }
 
-               if (last) {
-                       switch (verify_ordered(last, entry)) {
+               if (o_name) {
+                       switch (verify_ordered(o_mode, o_name, mode, name)) {
                        case TREE_UNORDERED:
                                not_properly_sorted = 1;
                                break;
@@ -198,17 +216,14 @@ static int fsck_tree(struct tree *item)
                        default:
                                break;
                        }
-                       free(last->name);
-                       free(last);
                }
 
-               last = entry;
+               o_mode = mode;
+               o_name = name;
+               o_sha1 = sha1;
        }
-       if (last) {
-               free(last->name);
-               free(last);
-       }
-       item->entries = NULL;
+       free(item->buffer);
+       item->buffer = NULL;
 
        retval = 0;
        if (has_full_path) {
@@ -268,7 +283,7 @@ static int fsck_tag(struct tag *tag)
        if (!show_tags)
                return 0;
 
-       printf("tagged %s %s", tagged->type, sha1_to_hex(tagged->sha1));
+       printf("tagged %s %s", typename(tagged->type), sha1_to_hex(tagged->sha1));
        printf(" (%s) in %s\n", tag->tag, sha1_to_hex(tag->object.sha1));
        return 0;
 }
@@ -278,16 +293,19 @@ static int fsck_sha1(unsigned char *sha1)
        struct object *obj = parse_object(sha1);
        if (!obj)
                return error("%s: object not found", sha1_to_hex(sha1));
-       if (obj->type == blob_type)
+       if (obj->flags & SEEN)
+               return 0;
+       obj->flags |= SEEN;
+       if (obj->type == TYPE_BLOB)
                return 0;
-       if (obj->type == tree_type)
+       if (obj->type == TYPE_TREE)
                return fsck_tree((struct tree *) obj);
-       if (obj->type == commit_type)
+       if (obj->type == TYPE_COMMIT)
                return fsck_commit((struct commit *) obj);
-       if (obj->type == tag_type)
+       if (obj->type == TYPE_TAG)
                return fsck_tag((struct tag *) obj);
        /* By now, parse_object() would've returned NULL instead. */
-       return objerror(obj, "unknown type '%s' (internal fsck error)", obj->type);
+       return objerror(obj, "unknown type '%d' (internal fsck error)", obj->type);
 }
 
 /*
@@ -453,7 +471,7 @@ static int fsck_cache_tree(struct cache_tree *it)
                }
                mark_reachable(obj, REACHABLE);
                obj->used = 1;
-               if (obj->type != tree_type)
+               if (obj->type != TYPE_TREE)
                        err |= objerror(obj, "non-tree in cache-tree");
        }
        for (i = 0; i < it->subtree_nr; i++)
@@ -465,6 +483,7 @@ int main(int argc, char **argv)
 {
        int i, heads;
 
+       track_object_refs = 1;
        setup_git_directory();
 
        for (i = 1; i < argc; i++) {