#include "tree-cache.h"
+#include "pool.h"
+#include "tree.h"
+
static git_tree_cache *find_child(
const git_tree_cache *tree, const char *path, const char *end)
{
if (tree == NULL)
return;
- tree->entries = -1;
+ tree->entry_count = -1;
while (ptr != NULL) {
end = strchr(ptr, '/');
if (tree == NULL) /* We don't have that tree */
return;
- tree->entries = -1;
+ tree->entry_count = -1;
ptr = end + 1;
}
}
}
static int read_tree_internal(git_tree_cache **out,
- const char **buffer_in, const char *buffer_end, git_tree_cache *parent)
+ const char **buffer_in, const char *buffer_end,
+ git_pool *pool)
{
git_tree_cache *tree = NULL;
const char *name_start, *buffer;
int count;
- size_t name_len;
buffer = name_start = *buffer_in;
if (++buffer >= buffer_end)
goto corrupted;
- name_len = strlen(name_start);
- tree = git__malloc(sizeof(git_tree_cache) + name_len + 1);
- GITERR_CHECK_ALLOC(tree);
-
- memset(tree, 0x0, sizeof(git_tree_cache));
- tree->parent = parent;
-
- /* NUL-terminated tree name */
- tree->namelen = name_len;
- memcpy(tree->name, name_start, name_len);
- tree->name[name_len] = '\0';
+ if (git_tree_cache_new(&tree, name_start, pool) < 0)
+ return -1;
/* Blank-terminated ASCII decimal number of entries in this tree */
- if (git__strtol32(&count, buffer, &buffer, 10) < 0)
+ if (git__strntol32(&count, buffer, buffer_end - buffer, &buffer, 10) < 0)
goto corrupted;
- tree->entries = count;
+ tree->entry_count = count;
if (*buffer != ' ' || ++buffer >= buffer_end)
goto corrupted;
/* Number of children of the tree, newline-terminated */
- if (git__strtol32(&count, buffer, &buffer, 10) < 0 || count < 0)
+ if (git__strntol32(&count, buffer, buffer_end - buffer, &buffer, 10) < 0 || count < 0)
goto corrupted;
tree->children_count = count;
goto corrupted;
/* The SHA1 is only there if it's not invalidated */
- if (tree->entries >= 0) {
+ if (tree->entry_count >= 0) {
/* 160-bit SHA-1 for this tree and it's children */
if (buffer + GIT_OID_RAWSZ > buffer_end)
goto corrupted;
/* Parse children: */
if (tree->children_count > 0) {
- unsigned int i;
+ size_t i, bufsize;
+
+ GIT_ERROR_CHECK_ALLOC_MULTIPLY(&bufsize, tree->children_count, sizeof(git_tree_cache*));
- tree->children = git__malloc(tree->children_count * sizeof(git_tree_cache *));
- GITERR_CHECK_ALLOC(tree->children);
+ tree->children = git_pool_malloc(pool, bufsize);
+ GIT_ERROR_CHECK_ALLOC(tree->children);
- memset(tree->children, 0x0, tree->children_count * sizeof(git_tree_cache *));
+ memset(tree->children, 0x0, bufsize);
for (i = 0; i < tree->children_count; ++i) {
- if (read_tree_internal(&tree->children[i], &buffer, buffer_end, tree) < 0)
+ if (read_tree_internal(&tree->children[i], &buffer, buffer_end, pool) < 0)
goto corrupted;
}
}
return 0;
corrupted:
- git_tree_cache_free(tree);
- giterr_set(GITERR_INDEX, "Corrupted TREE extension in index");
+ git_error_set(GIT_ERROR_INDEX, "corrupted TREE extension in index");
return -1;
}
-int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size)
+int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool)
{
const char *buffer_end = buffer + buffer_size;
- if (read_tree_internal(tree, &buffer, buffer_end, NULL) < 0)
+ if (read_tree_internal(tree, &buffer, buffer_end, pool) < 0)
return -1;
if (buffer < buffer_end) {
- giterr_set(GITERR_INDEX, "Corrupted TREE extension in index (unexpected trailing data)");
+ git_error_set(GIT_ERROR_INDEX, "corrupted TREE extension in index (unexpected trailing data)");
return -1;
}
return 0;
}
-void git_tree_cache_free(git_tree_cache *tree)
+static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_pool *pool)
{
- unsigned int i;
+ git_repository *repo;
+ size_t i, j, nentries, ntrees, alloc_size;
+ int error;
+
+ repo = git_tree_owner(tree);
+
+ git_oid_cpy(&cache->oid, git_tree_id(tree));
+ nentries = git_tree_entrycount(tree);
+
+ /*
+ * We make sure we know how many trees we need to allocate for
+ * so we don't have to realloc and change the pointers for the
+ * parents.
+ */
+ ntrees = 0;
+ for (i = 0; i < nentries; i++) {
+ const git_tree_entry *entry;
+
+ entry = git_tree_entry_byindex(tree, i);
+ if (git_tree_entry_filemode(entry) == GIT_FILEMODE_TREE)
+ ntrees++;
+ }
- if (tree == NULL)
- return;
+ GIT_ERROR_CHECK_ALLOC_MULTIPLY(&alloc_size, ntrees, sizeof(git_tree_cache *));
+
+ cache->children_count = ntrees;
+ cache->children = git_pool_mallocz(pool, alloc_size);
+ GIT_ERROR_CHECK_ALLOC(cache->children);
- if (tree->children != NULL) {
- for (i = 0; i < tree->children_count; ++i)
- git_tree_cache_free(tree->children[i]);
+ j = 0;
+ for (i = 0; i < nentries; i++) {
+ const git_tree_entry *entry;
+ git_tree *subtree;
- git__free(tree->children);
+ entry = git_tree_entry_byindex(tree, i);
+ if (git_tree_entry_filemode(entry) != GIT_FILEMODE_TREE) {
+ cache->entry_count++;
+ continue;
+ }
+
+ if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), pool)) < 0)
+ return error;
+
+ if ((error = git_tree_lookup(&subtree, repo, git_tree_entry_id(entry))) < 0)
+ return error;
+
+ error = read_tree_recursive(cache->children[j], subtree, pool);
+ git_tree_free(subtree);
+ cache->entry_count += cache->children[j]->entry_count;
+ j++;
+
+ if (error < 0)
+ return error;
}
- git__free(tree);
+ return 0;
+}
+
+int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool)
+{
+ int error;
+ git_tree_cache *cache;
+
+ if ((error = git_tree_cache_new(&cache, "", pool)) < 0)
+ return error;
+
+ if ((error = read_tree_recursive(cache, tree, pool)) < 0)
+ return error;
+
+ *out = cache;
+ return 0;
+}
+
+int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
+{
+ size_t name_len, alloc_size;
+ git_tree_cache *tree;
+
+ name_len = strlen(name);
+
+ GIT_ERROR_CHECK_ALLOC_ADD3(&alloc_size, sizeof(git_tree_cache), name_len, 1);
+
+ tree = git_pool_malloc(pool, alloc_size);
+ GIT_ERROR_CHECK_ALLOC(tree);
+
+ memset(tree, 0x0, sizeof(git_tree_cache));
+ /* NUL-terminated tree name */
+ tree->namelen = name_len;
+ memcpy(tree->name, name, name_len);
+ tree->name[name_len] = '\0';
+
+ *out = tree;
+ return 0;
+}
+
+static void write_tree(git_buf *out, git_tree_cache *tree)
+{
+ size_t i;
+
+ git_buf_printf(out, "%s%c%"PRIdZ" %"PRIuZ"\n", tree->name, 0, tree->entry_count, tree->children_count);
+
+ if (tree->entry_count != -1)
+ git_buf_put(out, (const char *) &tree->oid, GIT_OID_RAWSZ);
+
+ for (i = 0; i < tree->children_count; i++)
+ write_tree(out, tree->children[i]);
+}
+
+int git_tree_cache_write(git_buf *out, git_tree_cache *tree)
+{
+ write_tree(out, tree);
+
+ return git_buf_oom(out) ? -1 : 0;
}
projects / libgit2.git / blobdiff