Make "tree_entry" have a SHA1 instead of a union of object pointers

This is preparatory work for further cleanups, where we try to make
tree_entry look more like the more efficient tree-walk descriptor.

Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>

diff --git a/blame.c b/blame.c
index 99ceea81df7b7c69bc263cf170cbb23d88420613..88bfec262f741a80ee4aac6ef19d7cf359559464 100644 (file)
--- a/blame.c
+++ b/blame.c
@@ -149,7 +149,7 @@ static void free_patch(struct patch *p)
        free(p);
 }
 
        free(p);
 }
 

-static int get_blob_sha1_internal(unsigned char *sha1, const char *base,
+static int get_blob_sha1_internal(const unsigned char *sha1, const char *base,

                                  int baselen, const char *pathname,
                                  unsigned mode, int stage);
 
                                  int baselen, const char *pathname,
                                  unsigned mode, int stage);
 


@@ -178,7 +178,7 @@ static int get_blob_sha1(struct tree *t, const char *pathname,
        return 0;
 }
 
        return 0;
 }
 

-static int get_blob_sha1_internal(unsigned char *sha1, const char *base,
+static int get_blob_sha1_internal(const unsigned char *sha1, const char *base,

                                  int baselen, const char *pathname,
                                  unsigned mode, int stage)
 {
                                  int baselen, const char *pathname,
                                  unsigned mode, int stage)
 {

diff --git a/builtin-read-tree.c b/builtin-read-tree.c
index 6876f3d79391ce1d73a830336769be4f49644e0f..5e513c85caee73d96a6efe862400e88ca43d717d 100644 (file)
--- a/builtin-read-tree.c
+++ b/builtin-read-tree.c
@@ -161,9 +161,10 @@ static int unpack_trees_rec(struct tree_entry_list **posns, int len,
                        }
 
                        if (posns[i]->directory) {
                        }
 
                        if (posns[i]->directory) {

+                               struct tree *tree = lookup_tree(posns[i]->sha1);

                                any_dirs = 1;
                                any_dirs = 1;

-                               parse_tree(posns[i]->item.tree);
-                               subposns[i] = posns[i]->item.tree->entries;
+                               parse_tree(tree);
+                               subposns[i] = tree->entries;

                                posns[i] = posns[i]->next;
                                src[i + merge] = &df_conflict_entry;
                                continue;
                                posns[i] = posns[i]->next;
                                src[i + merge] = &df_conflict_entry;
                                continue;


@@ -187,7 +188,7 @@ static int unpack_trees_rec(struct tree_entry_list **posns, int len,
 
                        any_files = 1;
 
 
                        any_files = 1;
 

-                       memcpy(ce->sha1, posns[i]->item.any->sha1, 20);
+                       memcpy(ce->sha1, posns[i]->sha1, 20);

                        src[i + merge] = ce;
                        subposns[i] = &df_conflict_list;
                        posns[i] = posns[i]->next;
                        src[i + merge] = ce;
                        subposns[i] = &df_conflict_list;
                        posns[i] = posns[i]->next;


@@ -783,7 +784,7 @@ static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
                        cnt++;
                else {
                        struct cache_tree_sub *sub;
                        cnt++;
                else {
                        struct cache_tree_sub *sub;

-                       struct tree *subtree = (struct tree *)ent->item.tree;
+                       struct tree *subtree = lookup_tree(ent->sha1);

                        if (!subtree->object.parsed)
                                parse_tree(subtree);
                        sub = cache_tree_sub(it, ent->name);
                        if (!subtree->object.parsed)
                                parse_tree(subtree);
                        sub = cache_tree_sub(it, ent->name);

diff --git a/builtin-rev-list.c b/builtin-rev-list.c
index 72c1549c701f24dc46eaf920fdcb73f822cf5cda..94f520b908402ffd6468cc15f894d7a9d56ebbf7 100644 (file)
--- a/builtin-rev-list.c
+++ b/builtin-rev-list.c
@@ -133,9 +133,9 @@ static struct object_list **process_tree(struct tree *tree,
        while (entry) {
                struct tree_entry_list *next = entry->next;
                if (entry->directory)
        while (entry) {
                struct tree_entry_list *next = entry->next;
                if (entry->directory)

-                       p = process_tree(entry->item.tree, p, &me, entry->name);
+                       p = process_tree(lookup_tree(entry->sha1), p, &me, entry->name);

                else
                else

-                       p = process_blob(entry->item.blob, p, &me, entry->name);
+                       p = process_blob(lookup_blob(entry->sha1), p, &me, entry->name);

                free(entry);
                entry = next;
        }
                free(entry);
                entry = next;
        }

diff --git a/fsck-objects.c b/fsck-objects.c
index 5e65df436ba8e4191530ec6f9351d5e069928412..ed2eb278ec38b239f34135de2cd28b9f4b1cc3be 100644 (file)
--- a/fsck-objects.c
+++ b/fsck-objects.c
@@ -464,6 +464,7 @@ int main(int argc, char **argv)
 {
        int i, heads;
 
 {
        int i, heads;
 

+       track_object_refs = 1;

        setup_git_directory();
 
        for (i = 1; i < argc; i++) {
        setup_git_directory();
 
        for (i = 1; i < argc; i++) {

diff --git a/http-push.c b/http-push.c
index b4327d92438d9596b7286ead06152ad3156b6e2c..f492a5d36678a996ff2c665cacc8cfc69eb10f6f 100644 (file)
--- a/http-push.c
+++ b/http-push.c
@@ -1733,9 +1733,9 @@ static struct object_list **process_tree(struct tree *tree,
        while (entry) {
                struct tree_entry_list *next = entry->next;
                if (entry->directory)
        while (entry) {
                struct tree_entry_list *next = entry->next;
                if (entry->directory)

-                       p = process_tree(entry->item.tree, p, &me, entry->name);
+                       p = process_tree(lookup_tree(entry->sha1), p, &me, entry->name);

                else
                else

-                       p = process_blob(entry->item.blob, p, &me, entry->name);
+                       p = process_blob(lookup_blob(entry->sha1), p, &me, entry->name);

                free(entry);
                entry = next;
        }
                free(entry);
                entry = next;
        }

diff --git a/object.c b/object.c
index 1a7823c234406a418d360bf5ea322fe2321aec06..9adc87479bde2a0b2a0a0335aed12a9f485facff 100644 (file)
--- a/object.c
+++ b/object.c
@@ -9,7 +9,7 @@ struct object **objs;
 static int nr_objs;
 int obj_allocs;
 
 static int nr_objs;
 int obj_allocs;
 

-int track_object_refs = 1;
+int track_object_refs = 0;

 
 static int hashtable_index(const unsigned char *sha1)
 {
 
 static int hashtable_index(const unsigned char *sha1)
 {

diff --git a/revision.c b/revision.c
index 42c077a4cbc74b99dac516a0d55110892c1a132f..8d70a6f77a56d4a413e77015258db136f6cb7410 100644 (file)
--- a/revision.c
+++ b/revision.c
@@ -68,9 +68,9 @@ void mark_tree_uninteresting(struct tree *tree)
        while (entry) {
                struct tree_entry_list *next = entry->next;
                if (entry->directory)
        while (entry) {
                struct tree_entry_list *next = entry->next;
                if (entry->directory)

-                       mark_tree_uninteresting(entry->item.tree);
+                       mark_tree_uninteresting(lookup_tree(entry->sha1));

                else
                else

-                       mark_blob_uninteresting(entry->item.blob);
+                       mark_blob_uninteresting(lookup_blob(entry->sha1));

                free(entry);
                entry = next;
        }
                free(entry);
                entry = next;
        }

diff --git a/tree.c b/tree.c
index 1e76d9cc11dcbda655e40f19fbd82d34212383b2..88c22190307b2f86ef365af66ddcc71ba4cb2fb4 100644 (file)
--- a/tree.c
+++ b/tree.c
@@ -8,7 +8,7 @@
 
 const char *tree_type = "tree";
 
 
 const char *tree_type = "tree";
 

-static int read_one_entry(unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode, int stage)
+static int read_one_entry(const unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode, int stage)

 {
        int len;
        unsigned int size;
 {
        int len;
        unsigned int size;


@@ -89,7 +89,7 @@ int read_tree_recursive(struct tree *tree,
                                      current->mode, match))
                        continue;
 
                                      current->mode, match))
                        continue;
 

-               switch (fn(current->item.any->sha1, base, baselen,
+               switch (fn(current->sha1, base, baselen,

                           current->name, current->mode, stage)) {
                case 0:
                        continue;
                           current->name, current->mode, stage)) {
                case 0:
                        continue;


@@ -107,7 +107,7 @@ int read_tree_recursive(struct tree *tree,
                        memcpy(newbase, base, baselen);
                        memcpy(newbase + baselen, current->name, pathlen);
                        newbase[baselen + pathlen] = '/';
                        memcpy(newbase, base, baselen);
                        memcpy(newbase + baselen, current->name, pathlen);
                        newbase[baselen + pathlen] = '/';

-                       retval = read_tree_recursive(current->item.tree,
+                       retval = read_tree_recursive(lookup_tree(current->sha1),

                                                     newbase,
                                                     baselen + pathlen + 1,
                                                     stage, match, fn);
                                                     newbase,
                                                     baselen + pathlen + 1,
                                                     stage, match, fn);


@@ -170,6 +170,7 @@ int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
 
                entry = xmalloc(sizeof(struct tree_entry_list));
                entry->name = path;
 
                entry = xmalloc(sizeof(struct tree_entry_list));
                entry->name = path;

+               entry->sha1 = sha1;

                entry->mode = mode;
                entry->directory = S_ISDIR(mode) != 0;
                entry->executable = (mode & S_IXUSR) != 0;
                entry->mode = mode;
                entry->directory = S_ISDIR(mode) != 0;
                entry->executable = (mode & S_IXUSR) != 0;


@@ -178,12 +179,6 @@ int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
                entry->next = NULL;
 
                update_tree_entry(&desc);
                entry->next = NULL;
 
                update_tree_entry(&desc);

-
-               if (entry->directory) {
-                       entry->item.tree = lookup_tree(sha1);
-               } else {
-                       entry->item.blob = lookup_blob(sha1);
-               }

                n_refs++;
                *list_p = entry;
                list_p = &entry->next;
                n_refs++;
                *list_p = entry;
                list_p = &entry->next;


@@ -193,8 +188,16 @@ int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
                struct tree_entry_list *entry;
                unsigned i = 0;
                struct object_refs *refs = alloc_object_refs(n_refs);
                struct tree_entry_list *entry;
                unsigned i = 0;
                struct object_refs *refs = alloc_object_refs(n_refs);

-               for (entry = item->entries; entry; entry = entry->next)
-                       refs->ref[i++] = entry->item.any;
+               for (entry = item->entries; entry; entry = entry->next) {
+                       struct object *obj;
+
+                       if (entry->directory)
+                               obj = &lookup_tree(entry->sha1)->object;
+                       else
+                               obj = &lookup_blob(entry->sha1)->object;
+                       refs->ref[i++] = obj;
+               }
+

                set_object_refs(&item->object, refs);
        }
 
                set_object_refs(&item->object, refs);
        }
 

diff --git a/tree.h b/tree.h
index 066ac5d5bfa38ec8b61e4a8c9b1d75c1959eaa03..a27bae41ba48c7f04f7abda0bfce25587eb46ebe 100644 (file)
--- a/tree.h
+++ b/tree.h
@@ -13,11 +13,7 @@ struct tree_entry_list {
        unsigned zeropad : 1;
        unsigned int mode;
        const char *name;
        unsigned zeropad : 1;
        unsigned int mode;
        const char *name;

-       union {
-               struct object *any;
-               struct tree *tree;
-               struct blob *blob;
-       } item;
+       const unsigned char *sha1;

 };
 
 struct tree {
 };
 
 struct tree {


@@ -37,7 +33,7 @@ int parse_tree(struct tree *tree);
 struct tree *parse_tree_indirect(const unsigned char *sha1);
 
 #define READ_TREE_RECURSIVE 1
 struct tree *parse_tree_indirect(const unsigned char *sha1);
 
 #define READ_TREE_RECURSIVE 1

-typedef int (*read_tree_fn_t)(unsigned char *, const char *, int, const char *, unsigned int, int);
+typedef int (*read_tree_fn_t)(const unsigned char *, const char *, int, const char *, unsigned int, int);

 
 extern int read_tree_recursive(struct tree *tree,
                               const char *base, int baselen,
 
 extern int read_tree_recursive(struct tree *tree,
                               const char *base, int baselen,