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 8d163c0625991ded9789ed3e54d2e43e69cd9dfc..497a05b8fa8e9aa3a5db9b42e5c50392f352d2b4 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 0d7852f7f295d9fb85b00a71bcb7cfbeb1acd026..4fe64ce0b4f99e749a6358dab2c72c36ff98e139 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 ac8375a7f0e89dca5a2af30fce52f3b766dd153c..91b2628e3c18e7f75e477c24197d9ef2eca14125 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 6e531b40a84914cf1b37e12f8629fecbec0ae041..f6358d76f1301dc2933e7cf1c3d9bc77ac123b06 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;
 }