This implements the new "recursive tree" write-tree.

It's got some debugging printouts etc still in it, but testing on the
kernel seems to show that it does indeed fix the issue with huge tree
files for each commit.

diff --git a/cache.h b/cache.h
index 8d163c0..497a05b 100644 (file)
--- a/cache.h
+++ b/cache.h
@@ -96,7 +96,7 @@ extern int write_sha1_buffer(unsigned char *sha1, void *buf, unsigned int size);
 extern void * map_sha1_file(unsigned char *sha1, unsigned long *size);
 extern void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size);
 extern void * read_sha1_file(unsigned char *sha1, char *type, unsigned long *size);
-extern int write_sha1_file(char *buf, unsigned len);
+extern int write_sha1_file(char *buf, unsigned len, unsigned char *return_sha1);
 extern int check_sha1_signature(unsigned char *sha1, void *buf, unsigned long size);
 
 /* Convert to/from hex/sha1 representation */

diff --git a/commit-tree.c b/commit-tree.c
index 0d7852f..4fe64ce 100644 (file)
--- a/commit-tree.c
+++ b/commit-tree.c
@@ -111,6 +111,7 @@ int main(int argc, char **argv)
        int parents = 0;
        unsigned char tree_sha1[20];
        unsigned char parent_sha1[MAXPARENT][20];
+       unsigned char commit_sha1[20];
        char *gecos, *realgecos;
        char *email, realemail[1000];
        char *date, *realdate;
@@ -172,6 +173,7 @@ int main(int argc, char **argv)
 
        finish_buffer("commit ", &buffer, &size);
 
-       write_sha1_file(buffer, size);
+       write_sha1_file(buffer, size, commit_sha1);
+       printf("%s\n", sha1_to_hex(commit_sha1));
        return 0;
 }

diff --git a/read-cache.c b/read-cache.c
index ac8375a..91b2628 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
@@ -168,7 +168,7 @@ void * read_sha1_file(unsigned char *sha1, char *type, unsigned long *size)
        return NULL;
 }
 
-int write_sha1_file(char *buf, unsigned len)
+int write_sha1_file(char *buf, unsigned len, unsigned char *returnsha1)
 {
        int size;
        char *compressed;
@@ -199,7 +199,8 @@ int write_sha1_file(char *buf, unsigned len)
 
        if (write_sha1_buffer(sha1, compressed, size) < 0)
                return -1;
-       printf("%s\n", sha1_to_hex(sha1));
+       if (returnsha1)
+               memcpy(returnsha1, sha1, 20);
        return 0;
 }
 

diff --git a/write-tree.c b/write-tree.c
index 6e531b4..f6358d7 100644 (file)
--- a/write-tree.c
+++ b/write-tree.c
@@ -29,35 +29,67 @@ static int prepend_integer(char *buffer, unsigned val, int i)
 
 #define ORIG_OFFSET (40)       /* Enough space to add the header of "tree <size>\0" */
 
-int main(int argc, char **argv)
+static int write_tree(struct cache_entry **cachep, int maxentries, const char *base, int baselen, unsigned char *returnsha1)
 {
+       unsigned char subdir_sha1[20];
        unsigned long size, offset;
-       int i, entries = read_cache();
        char *buffer;
+       int i, nr;
 
-       if (entries <= 0) {
-               fprintf(stderr, "No file-cache to create a tree of\n");
-               exit(1);
-       }
-
-       /* Guess at an initial size */
-       size = entries * 40 + 400;
+       /* Guess at some random initial size */
+       size = 8192;
        buffer = malloc(size);
        offset = ORIG_OFFSET;
 
-       for (i = 0; i < entries; i++) {
-               struct cache_entry *ce = active_cache[i];
-               if (check_valid_sha1(ce->sha1) < 0)
+       nr = 0;
+       do {
+               struct cache_entry *ce = cachep[nr];
+               const char *pathname = ce->name, *filename, *dirname;
+               int pathlen = ce->namelen, entrylen;
+               unsigned char *sha1;
+               unsigned int mode;
+
+               /* Did we hit the end of the directory? Return how many we wrote */
+               if (baselen >= pathlen || memcmp(base, pathname, baselen))
+                       break;
+
+               sha1 = ce->sha1;
+               mode = ce->st_mode;
+
+               /* Do we have _further_ subdirectories? */
+               filename = pathname + baselen;
+               dirname = strchr(filename, '/');
+               if (dirname) {
+                       int subdir_written;
+
+                       subdir_written = write_tree(cachep + nr, maxentries - nr, pathname, dirname-pathname+1, subdir_sha1);
+                       fprintf(stderr, "Wrote %d entries from subdirectory '%.*s'\n", 
+                               subdir_written, dirname-pathname, pathname);
+                       nr += subdir_written;
+
+                       /* Now we need to write out the directory entry into this tree.. */
+                       mode = S_IFDIR;
+                       pathlen = dirname - pathname;
+
+                       /* ..but the directory entry doesn't count towards the total count */
+                       nr--;
+                       sha1 = subdir_sha1;
+               }
+
+               if (check_valid_sha1(sha1) < 0)
                        exit(1);
-               if (offset + ce->namelen + 60 > size) {
-                       size = alloc_nr(offset + ce->namelen + 60);
+
+               entrylen = pathlen - baselen;
+               if (offset + entrylen + 100 > size) {
+                       size = alloc_nr(offset + entrylen + 100);
                        buffer = realloc(buffer, size);
                }
-               offset += sprintf(buffer + offset, "%o %s", ce->st_mode, ce->name);
+               offset += sprintf(buffer + offset, "%o %.*s", mode, entrylen, filename);
                buffer[offset++] = 0;
-               memcpy(buffer + offset, ce->sha1, 20);
+               memcpy(buffer + offset, sha1, 20);
                offset += 20;
-       }
+               nr++;
+       } while (nr < maxentries);
 
        i = prepend_integer(buffer, offset - ORIG_OFFSET, ORIG_OFFSET);
        i -= 5;
@@ -66,6 +98,19 @@ int main(int argc, char **argv)
        buffer += i;
        offset -= i;
 
-       write_sha1_file(buffer, offset);
+       write_sha1_file(buffer, offset, returnsha1);
+       return nr;
+}
+
+int main(int argc, char **argv)
+{
+       int entries = read_cache();
+       unsigned char sha1[20];
+
+       if (entries <= 0)
+               usage("no cache contents to write");
+       if (write_tree(active_cache, entries, "", 0, sha1) != entries)
+               usage("write-tree: internal error");
+       printf("%s\n", sha1_to_hex(sha1));
        return 0;
 }