diff options
Diffstat (limited to 'src/tree.c')
| -rw-r--r-- | src/tree.c | 647 |
1 files changed, 405 insertions, 242 deletions
diff --git a/src/tree.c b/src/tree.c index 92b1b1e39..17b3c378d 100644 --- a/src/tree.c +++ b/src/tree.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009-2012 the libgit2 contributors + * Copyright (C) the libgit2 contributors. All rights reserved. * * This file is part of libgit2, distributed under the GNU GPL v2 with * a Linking Exception. For full terms see the included COPYING file. @@ -12,29 +12,89 @@ #include "git2/object.h" #define DEFAULT_TREE_SIZE 16 -#define MAX_FILEMODE 0777777 #define MAX_FILEMODE_BYTES 6 -static int valid_attributes(const int attributes) +static bool valid_filemode(const int filemode) { - return attributes >= 0 && attributes <= MAX_FILEMODE; + return (filemode == GIT_FILEMODE_TREE + || filemode == GIT_FILEMODE_BLOB + || filemode == GIT_FILEMODE_BLOB_EXECUTABLE + || filemode == GIT_FILEMODE_LINK + || filemode == GIT_FILEMODE_COMMIT); +} + +GIT_INLINE(git_filemode_t) normalize_filemode(git_filemode_t filemode) +{ + /* Tree bits set, but it's not a commit */ + if (filemode & GIT_FILEMODE_TREE && !(filemode & 0100000)) + return GIT_FILEMODE_TREE; + + /* If any of the x bits is set */ + if (filemode & 0111) + return GIT_FILEMODE_BLOB_EXECUTABLE; + + /* 16XXXX means commit */ + if ((filemode & GIT_FILEMODE_COMMIT) == GIT_FILEMODE_COMMIT) + return GIT_FILEMODE_COMMIT; + + /* 12XXXX means commit */ + if ((filemode & GIT_FILEMODE_LINK) == GIT_FILEMODE_LINK) + return GIT_FILEMODE_LINK; + + /* Otherwise, return a blob */ + return GIT_FILEMODE_BLOB; } static int valid_entry_name(const char *filename) { - return strlen(filename) > 0 && strchr(filename, '/') == NULL; + return *filename != '\0' && + strchr(filename, '/') == NULL && + (*filename != '.' || + (strcmp(filename, ".") != 0 && + strcmp(filename, "..") != 0 && + strcmp(filename, DOT_GIT) != 0)); } static int entry_sort_cmp(const void *a, const void *b) { - const git_tree_entry *entry_a = (const git_tree_entry *)(a); - const git_tree_entry *entry_b = (const git_tree_entry *)(b); + const git_tree_entry *e1 = (const git_tree_entry *)a; + const git_tree_entry *e2 = (const git_tree_entry *)b; + + return git_path_cmp( + e1->filename, e1->filename_len, git_tree_entry__is_tree(e1), + e2->filename, e2->filename_len, git_tree_entry__is_tree(e2), + git__strncmp); +} + +int git_tree_entry_cmp(const git_tree_entry *e1, const git_tree_entry *e2) +{ + return entry_sort_cmp(e1, e2); +} +int git_tree_entry_icmp(const git_tree_entry *e1, const git_tree_entry *e2) +{ return git_path_cmp( - entry_a->filename, entry_a->filename_len, git_tree_entry__is_tree(entry_a), - entry_b->filename, entry_b->filename_len, git_tree_entry__is_tree(entry_b)); + e1->filename, e1->filename_len, git_tree_entry__is_tree(e1), + e2->filename, e2->filename_len, git_tree_entry__is_tree(e2), + git__strncasecmp); } +static git_tree_entry *alloc_entry(const char *filename) +{ + git_tree_entry *entry = NULL; + size_t filename_len = strlen(filename); + + entry = git__malloc(sizeof(git_tree_entry) + filename_len + 1); + if (!entry) + return NULL; + + memset(entry, 0x0, sizeof(git_tree_entry)); + memcpy(entry->filename, filename, filename_len); + entry->filename[filename_len] = 0; + entry->filename_len = filename_len; + + return entry; +} struct tree_key_search { const char *filename; @@ -76,74 +136,114 @@ static int homing_search_cmp(const void *key, const void *array_member) * ambiguous because of folder vs file sorting, we look linearly * around the area for our target file. */ -static int tree_key_search(git_vector *entries, const char *filename) +static int tree_key_search( + size_t *at_pos, git_vector *entries, const char *filename, size_t filename_len) { struct tree_key_search ksearch; const git_tree_entry *entry; - - int homing, i; + size_t homing, i; ksearch.filename = filename; - ksearch.filename_len = strlen(filename); + ksearch.filename_len = filename_len; /* Initial homing search; find an entry on the tree with * the same prefix as the filename we're looking for */ - homing = git_vector_bsearch2(entries, &homing_search_cmp, &ksearch); - if (homing < 0) - return homing; + if (git_vector_bsearch2(&homing, entries, &homing_search_cmp, &ksearch) < 0) + return GIT_ENOTFOUND; /* We found a common prefix. Look forward as long as * there are entries that share the common prefix */ - for (i = homing; i < (int)entries->length; ++i) { + for (i = homing; i < entries->length; ++i) { entry = entries->contents[i]; if (homing_search_cmp(&ksearch, entry) < 0) break; - if (strcmp(filename, entry->filename) == 0) - return i; + if (entry->filename_len == filename_len && + memcmp(filename, entry->filename, filename_len) == 0) { + if (at_pos) + *at_pos = i; + + return 0; + } } /* If we haven't found our filename yet, look backwards * too as long as we have entries with the same prefix */ - for (i = homing - 1; i >= 0; --i) { - entry = entries->contents[i]; + if (homing > 0) { + i = homing - 1; - if (homing_search_cmp(&ksearch, entry) > 0) - break; + do { + entry = entries->contents[i]; + + if (homing_search_cmp(&ksearch, entry) > 0) + break; - if (strcmp(filename, entry->filename) == 0) - return i; + if (entry->filename_len == filename_len && + memcmp(filename, entry->filename, filename_len) == 0) { + if (at_pos) + *at_pos = i; + + return 0; + } + } while (i-- > 0); } /* The filename doesn't exist at all */ return GIT_ENOTFOUND; } -void git_tree__free(git_tree *tree) +void git_tree_entry_free(git_tree_entry *entry) { - unsigned int i; + if (entry == NULL) + return; - for (i = 0; i < tree->entries.length; ++i) { - git_tree_entry *e; - e = git_vector_get(&tree->entries, i); + git__free(entry); +} - git__free(e->filename); - git__free(e); - } +git_tree_entry *git_tree_entry_dup(const git_tree_entry *entry) +{ + size_t total_size; + git_tree_entry *copy; + + assert(entry); + + total_size = sizeof(git_tree_entry) + entry->filename_len + 1; + + copy = git__malloc(total_size); + if (!copy) + return NULL; + + memcpy(copy, entry, total_size); + + return copy; +} + +void git_tree__free(git_tree *tree) +{ + size_t i; + git_tree_entry *e; + + git_vector_foreach(&tree->entries, i, e) + git_tree_entry_free(e); git_vector_free(&tree->entries); git__free(tree); } -const git_oid *git_tree_id(git_tree *c) +const git_oid *git_tree_id(const git_tree *t) +{ + return git_object_id((const git_object *)t); +} + +git_repository *git_tree_owner(const git_tree *t) { - return git_object_id((git_object *)c); + return git_object_owner((const git_object *)t); } -unsigned int git_tree_entry_attributes(const git_tree_entry *entry) +git_filemode_t git_tree_entry_filemode(const git_tree_entry *entry) { - return entry->attr; + return (git_filemode_t)entry->attr; } const char *git_tree_entry_name(const git_tree_entry *entry) @@ -179,36 +279,61 @@ int git_tree_entry_to_object( return git_object_lookup(object_out, repo, &entry->oid, GIT_OBJ_ANY); } -const git_tree_entry *git_tree_entry_byname(git_tree *tree, const char *filename) +static const git_tree_entry *entry_fromname( + git_tree *tree, const char *name, size_t name_len) { - int idx; - - assert(tree && filename); + size_t idx; - idx = tree_key_search(&tree->entries, filename); - if (idx == GIT_ENOTFOUND) + if (tree_key_search(&idx, &tree->entries, name, name_len) < 0) return NULL; return git_vector_get(&tree->entries, idx); } -const git_tree_entry *git_tree_entry_byindex(git_tree *tree, unsigned int idx) +const git_tree_entry *git_tree_entry_byname( + git_tree *tree, const char *filename) +{ + assert(tree && filename); + return entry_fromname(tree, filename, strlen(filename)); +} + +const git_tree_entry *git_tree_entry_byindex( + git_tree *tree, size_t idx) { assert(tree); return git_vector_get(&tree->entries, idx); } +const git_tree_entry *git_tree_entry_byoid( + const git_tree *tree, const git_oid *oid) +{ + size_t i; + const git_tree_entry *e; + + assert(tree); + + git_vector_foreach(&tree->entries, i, e) { + if (memcmp(&e->oid.id, &oid->id, sizeof(oid->id)) == 0) + return e; + } + + return NULL; +} + int git_tree__prefix_position(git_tree *tree, const char *path) { git_vector *entries = &tree->entries; struct tree_key_search ksearch; - unsigned int at_pos; + size_t at_pos; + + if (!path) + return 0; ksearch.filename = path; ksearch.filename_len = strlen(path); /* Find tree entry with appropriate prefix */ - git_vector_bsearch3(&at_pos, entries, &homing_search_cmp, &ksearch); + git_vector_bsearch2(&at_pos, entries, &homing_search_cmp, &ksearch); for (; at_pos < entries->length; ++at_pos) { const git_tree_entry *entry = entries->contents[at_pos]; @@ -222,18 +347,27 @@ int git_tree__prefix_position(git_tree *tree, const char *path) break; } - return at_pos; + return (int)at_pos; } -unsigned int git_tree_entrycount(git_tree *tree) +size_t git_tree_entrycount(const git_tree *tree) { assert(tree); return tree->entries.length; } -static int tree_error(const char *str) +unsigned int git_treebuilder_entrycount(git_treebuilder *bld) +{ + assert(bld); + return (unsigned int)bld->entrycount; +} + +static int tree_error(const char *str, const char *path) { - giterr_set(GITERR_TREE, "%s", str); + if (path) + giterr_set(GITERR_TREE, "%s - %s", str, path); + else + giterr_set(GITERR_TREE, "%s", str); return -1; } @@ -244,28 +378,31 @@ static int tree_parse_buffer(git_tree *tree, const char *buffer, const char *buf while (buffer < buffer_end) { git_tree_entry *entry; - int tmp; - - entry = git__calloc(1, sizeof(git_tree_entry)); - GITERR_CHECK_ALLOC(entry); + int attr; - if (git_vector_insert(&tree->entries, entry) < 0) - return -1; - - if (git__strtol32(&tmp, buffer, &buffer, 8) < 0 || - !buffer || !valid_attributes(tmp)) - return tree_error("Failed to parse tree. Can't parse attributes"); + if (git__strtol32(&attr, buffer, &buffer, 8) < 0 || !buffer) + return tree_error("Failed to parse tree. Can't parse filemode", NULL); - entry->attr = tmp; + attr = normalize_filemode(attr); /* make sure to normalize the filemode */ if (*buffer++ != ' ') - return tree_error("Failed to parse tree. Object is corrupted"); + return tree_error("Failed to parse tree. Object is corrupted", NULL); if (memchr(buffer, 0, buffer_end - buffer) == NULL) - return tree_error("Failed to parse tree. Object is corrupted"); + return tree_error("Failed to parse tree. Object is corrupted", NULL); + + /** Allocate the entry and store it in the entries vector */ + { + entry = alloc_entry(buffer); + GITERR_CHECK_ALLOC(entry); - entry->filename = git__strdup(buffer); - entry->filename_len = strlen(buffer); + if (git_vector_insert(&tree->entries, entry) < 0) { + git__free(entry); + return -1; + } + + entry->attr = attr; + } while (buffer < buffer_end && *buffer != 0) buffer++; @@ -285,14 +422,13 @@ int git_tree__parse(git_tree *tree, git_odb_object *obj) return tree_parse_buffer(tree, (char *)obj->raw.data, (char *)obj->raw.data + obj->raw.len); } -static unsigned int find_next_dir(const char *dirname, git_index *index, unsigned int start) +static size_t find_next_dir(const char *dirname, git_index *index, size_t start) { - unsigned int i, entries = git_index_entrycount(index); - size_t dirlen; + size_t dirlen, i, entries = git_index_entrycount(index); dirlen = strlen(dirname); for (i = start; i < entries; ++i) { - git_index_entry *entry = git_index_get(index, i); + const git_index_entry *entry = git_index_get_byindex(index, i); if (strlen(entry->path) < dirlen || memcmp(entry->path, dirname, dirlen) || (dirlen > 0 && entry->path[dirlen] != '/')) { @@ -303,22 +439,29 @@ static unsigned int find_next_dir(const char *dirname, git_index *index, unsigne return i; } -static int append_entry(git_treebuilder *bld, const char *filename, const git_oid *id, unsigned int attributes) +static int append_entry( + git_treebuilder *bld, + const char *filename, + const git_oid *id, + git_filemode_t filemode) { git_tree_entry *entry; - entry = git__calloc(1, sizeof(git_tree_entry)); - GITERR_CHECK_ALLOC(entry); + if (!valid_entry_name(filename)) + return tree_error("Failed to insert entry. Invalid name for a tree entry", filename); - entry->filename = git__strdup(filename); - entry->filename_len = strlen(entry->filename); + entry = alloc_entry(filename); + GITERR_CHECK_ALLOC(entry); git_oid_cpy(&entry->oid, id); - entry->attr = attributes; + entry->attr = (uint16_t)filemode; - if (git_vector_insert(&bld->entries, entry) < 0) + if (git_vector_insert(&bld->entries, entry) < 0) { + git__free(entry); return -1; + } + bld->entrycount++; return 0; } @@ -327,11 +470,10 @@ static int write_tree( git_repository *repo, git_index *index, const char *dirname, - unsigned int start) + size_t start) { git_treebuilder *bld = NULL; - - unsigned int i, entries = git_index_entrycount(index); + size_t i, entries = git_index_entrycount(index); int error; size_t dirname_len = strlen(dirname); const git_tree_cache *cache; @@ -339,13 +481,11 @@ static int write_tree( cache = git_tree_cache_get(index->tree, dirname); if (cache != NULL && cache->entries >= 0){ git_oid_cpy(oid, &cache->oid); - return find_next_dir(dirname, index, start); + return (int)find_next_dir(dirname, index, start); } - error = git_treebuilder_create(&bld, NULL); - if (bld == NULL) { + if ((error = git_treebuilder_create(&bld, NULL)) < 0 || bld == NULL) return -1; - } /* * This loop is unfortunate, but necessary. The index doesn't have @@ -353,8 +493,8 @@ static int write_tree( * need to keep track of the current position. */ for (i = start; i < entries; ++i) { - git_index_entry *entry = git_index_get(index, i); - char *filename, *next_slash; + const git_index_entry *entry = git_index_get_byindex(index, i); + const char *filename, *next_slash; /* * If we've left our (sub)tree, exit the loop and return. The @@ -385,7 +525,8 @@ static int write_tree( /* Write out the subtree */ written = write_tree(&sub_oid, repo, index, subdir, i); if (written < 0) { - tree_error("Failed to write subtree"); + tree_error("Failed to write subtree", subdir); + git__free(subdir); goto on_error; } else { i = written - 1; /* -1 because of the loop increment */ @@ -403,18 +544,15 @@ static int write_tree( } else { last_comp = subdir; } + error = append_entry(bld, last_comp, &sub_oid, S_IFDIR); git__free(subdir); - if (error < 0) { - tree_error("Failed to insert dir"); + if (error < 0) goto on_error; - } } else { error = append_entry(bld, filename, &entry->oid, entry->mode); - if (error < 0) { - tree_error("Failed to insert file"); + if (error < 0) goto on_error; - } } } @@ -422,43 +560,54 @@ static int write_tree( goto on_error; git_treebuilder_free(bld); - return i; + return (int)i; on_error: git_treebuilder_free(bld); return -1; } -int git_tree_create_fromindex(git_oid *oid, git_index *index) +int git_tree__write_index( + git_oid *oid, git_index *index, git_repository *repo) { int ret; - git_repository *repo; + bool old_ignore_case = false; - repo = (git_repository *)GIT_REFCOUNT_OWNER(index); + assert(oid && index && repo); - if (repo == NULL) - return tree_error("Failed to create tree. " - "The index file is not backed up by an existing repository"); + if (git_index_has_conflicts(index)) { + giterr_set(GITERR_INDEX, + "Cannot create a tree from a not fully merged index."); + return GIT_EUNMERGED; + } if (index->tree != NULL && index->tree->entries >= 0) { git_oid_cpy(oid, &index->tree->oid); return 0; } - /* The tree cache didn't help us */ + /* The tree cache didn't help us; we'll have to write + * out a tree. If the index is ignore_case, we must + * make it case-sensitive for the duration of the tree-write + * operation. */ + + if (index->ignore_case) { + old_ignore_case = true; + git_index__set_ignore_case(index, false); + } + ret = write_tree(oid, repo, index, "", 0); - return ret < 0 ? ret : 0; -} -static void sort_entries(git_treebuilder *bld) -{ - git_vector_sort(&bld->entries); + if (old_ignore_case) + git_index__set_ignore_case(index, true); + + return ret < 0 ? ret : 0; } int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source) { git_treebuilder *bld; - unsigned int i, source_entries = DEFAULT_TREE_SIZE; + size_t i, source_entries = DEFAULT_TREE_SIZE; assert(builder_p); @@ -472,10 +621,13 @@ int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source) goto on_error; if (source != NULL) { - for (i = 0; i < source->entries.length; ++i) { - git_tree_entry *entry_src = source->entries.contents[i]; + git_tree_entry *entry_src; - if (append_entry(bld, entry_src->filename, &entry_src->oid, entry_src->attr) < 0) + git_vector_foreach(&source->entries, i, entry_src) { + if (append_entry( + bld, entry_src->filename, + &entry_src->oid, + entry_src->attr) < 0) goto on_error; } } @@ -488,42 +640,46 @@ on_error: return -1; } -int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, const char *filename, const git_oid *id, unsigned int attributes) +int git_treebuilder_insert( + const git_tree_entry **entry_out, + git_treebuilder *bld, + const char *filename, + const git_oid *id, + git_filemode_t filemode) { git_tree_entry *entry; - int pos; + size_t pos; assert(bld && id && filename); - if (!valid_attributes(attributes)) - return tree_error("Failed to insert entry. Invalid attributes"); + if (!valid_filemode(filemode)) + return tree_error("Failed to insert entry. Invalid filemode for file", filename); if (!valid_entry_name(filename)) - return tree_error("Failed to insert entry. Invalid name for a tree entry"); + return tree_error("Failed to insert entry. Invalid name for a tree entry", filename); - pos = tree_key_search(&bld->entries, filename); - - if (pos >= 0) { + if (!tree_key_search(&pos, &bld->entries, filename, strlen(filename))) { entry = git_vector_get(&bld->entries, pos); - if (entry->removed) + if (entry->removed) { entry->removed = 0; + bld->entrycount++; + } } else { - entry = git__calloc(1, sizeof(git_tree_entry)); + entry = alloc_entry(filename); GITERR_CHECK_ALLOC(entry); - entry->filename = git__strdup(filename); - entry->filename_len = strlen(entry->filename); + if (git_vector_insert(&bld->entries, entry) < 0) { + git__free(entry); + return -1; + } + + bld->entrycount++; } git_oid_cpy(&entry->oid, id); - entry->attr = attributes; - - if (pos == GIT_ENOTFOUND) { - if (git_vector_insert(&bld->entries, entry) < 0) - return -1; - } + entry->attr = filemode; - if (entry_out != NULL) + if (entry_out) *entry_out = entry; return 0; @@ -531,13 +687,12 @@ int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, con static git_tree_entry *treebuilder_get(git_treebuilder *bld, const char *filename) { - int idx; + size_t idx; git_tree_entry *entry; assert(bld && filename); - idx = tree_key_search(&bld->entries, filename); - if (idx < 0) + if (tree_key_search(&idx, &bld->entries, filename, strlen(filename)) < 0) return NULL; entry = git_vector_get(&bld->entries, idx); @@ -557,27 +712,29 @@ int git_treebuilder_remove(git_treebuilder *bld, const char *filename) git_tree_entry *remove_ptr = treebuilder_get(bld, filename); if (remove_ptr == NULL || remove_ptr->removed) - return tree_error("Failed to remove entry. File isn't in the tree"); + return tree_error("Failed to remove entry. File isn't in the tree", filename); remove_ptr->removed = 1; + bld->entrycount--; return 0; } int git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *bld) { - unsigned int i; + int error = 0; + size_t i; git_buf tree = GIT_BUF_INIT; git_odb *odb; assert(bld); - sort_entries(bld); + git_vector_sort(&bld->entries); /* Grow the buffer beforehand to an estimated size */ - git_buf_grow(&tree, bld->entries.length * 72); + error = git_buf_grow(&tree, bld->entries.length * 72); - for (i = 0; i < bld->entries.length; ++i) { - git_tree_entry *entry = bld->entries.contents[i]; + for (i = 0; i < bld->entries.length && !error; ++i) { + git_tree_entry *entry = git_vector_get(&bld->entries, i); if (entry->removed) continue; @@ -585,153 +742,154 @@ int git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *b git_buf_printf(&tree, "%o ", entry->attr); git_buf_put(&tree, entry->filename, entry->filename_len + 1); git_buf_put(&tree, (char *)entry->oid.id, GIT_OID_RAWSZ); - } - if (git_buf_oom(&tree)) - goto on_error; - - if (git_repository_odb__weakptr(&odb, repo) < 0) - goto on_error; - - - if (git_odb_write(oid, odb, tree.ptr, tree.size, GIT_OBJ_TREE) < 0) - goto on_error; + if (git_buf_oom(&tree)) + error = -1; + } - git_buf_free(&tree); - return 0; + if (!error && + !(error = git_repository_odb__weakptr(&odb, repo))) + error = git_odb_write(oid, odb, tree.ptr, tree.size, GIT_OBJ_TREE); -on_error: git_buf_free(&tree); - return -1; + return error; } -void git_treebuilder_filter(git_treebuilder *bld, int (*filter)(const git_tree_entry *, void *), void *payload) +void git_treebuilder_filter( + git_treebuilder *bld, + git_treebuilder_filter_cb filter, + void *payload) { - unsigned int i; + size_t i; + git_tree_entry *entry; assert(bld && filter); - for (i = 0; i < bld->entries.length; ++i) { - git_tree_entry *entry = bld->entries.contents[i]; - if (!entry->removed && filter(entry, payload)) + git_vector_foreach(&bld->entries, i, entry) { + if (!entry->removed && filter(entry, payload)) { entry->removed = 1; + bld->entrycount--; + } } } void git_treebuilder_clear(git_treebuilder *bld) { - unsigned int i; + size_t i; + git_tree_entry *e; + assert(bld); - for (i = 0; i < bld->entries.length; ++i) { - git_tree_entry *e = bld->entries.contents[i]; - git__free(e->filename); - git__free(e); - } + git_vector_foreach(&bld->entries, i, e) + git_tree_entry_free(e); git_vector_clear(&bld->entries); + bld->entrycount = 0; } void git_treebuilder_free(git_treebuilder *bld) { + if (bld == NULL) + return; + git_treebuilder_clear(bld); git_vector_free(&bld->entries); git__free(bld); } -static int tree_frompath( - git_tree **parent_out, +static size_t subpath_len(const char *path) +{ + const char *slash_pos = strchr(path, '/'); + if (slash_pos == NULL) + return strlen(path); + + return slash_pos - path; +} + +int git_tree_entry_bypath( + git_tree_entry **entry_out, git_tree *root, - git_buf *treeentry_path, - size_t offset) + const char *path) { - char *slash_pos = NULL; - const git_tree_entry* entry; int error = 0; git_tree *subtree; + const git_tree_entry *entry; + size_t filename_len; - if (!*(treeentry_path->ptr + offset)) { - giterr_set(GITERR_INVALID, - "Invalid relative path to a tree entry '%s'.", treeentry_path->ptr); - return -1; - } - - slash_pos = (char *)strchr(treeentry_path->ptr + offset, '/'); + /* Find how long is the current path component (i.e. + * the filename between two slashes */ + filename_len = subpath_len(path); - if (slash_pos == NULL) - return git_tree_lookup( - parent_out, - root->object.repo, - git_object_id((const git_object *)root) - ); - - if (slash_pos == treeentry_path->ptr + offset) { - giterr_set(GITERR_INVALID, - "Invalid relative path to a tree entry '%s'.", treeentry_path->ptr); - return -1; + if (filename_len == 0) { + giterr_set(GITERR_TREE, "Invalid tree path given"); + return GIT_ENOTFOUND; } - *slash_pos = '\0'; - - entry = git_tree_entry_byname(root, treeentry_path->ptr + offset); - - if (slash_pos != NULL) - *slash_pos = '/'; + entry = entry_fromname(root, path, filename_len); if (entry == NULL) { giterr_set(GITERR_TREE, - "No tree entry can be found from " - "the given tree and relative path '%s'.", treeentry_path->ptr); + "The path '%s' does not exist in the given tree", path); return GIT_ENOTFOUND; } + switch (path[filename_len]) { + case '/': + /* If there are more components in the path... + * then this entry *must* be a tree */ + if (!git_tree_entry__is_tree(entry)) { + giterr_set(GITERR_TREE, + "The path '%s' does not exist in the given tree", path); + return GIT_ENOTFOUND; + } + + /* If there's only a slash left in the path, we + * return the current entry; otherwise, we keep + * walking down the path */ + if (path[filename_len + 1] != '\0') + break; + + case '\0': + /* If there are no more components in the path, return + * this entry */ + *entry_out = git_tree_entry_dup(entry); + return 0; + } if (git_tree_lookup(&subtree, root->object.repo, &entry->oid) < 0) - return error; + return -1; - error = tree_frompath( - parent_out, + error = git_tree_entry_bypath( + entry_out, subtree, - treeentry_path, - (slash_pos - treeentry_path->ptr) + 1 + path + filename_len + 1 ); git_tree_free(subtree); return error; } -int git_tree_get_subtree( - git_tree **subtree, - git_tree *root, - const char *subtree_path) -{ - int error; - git_buf buffer = GIT_BUF_INIT; - - assert(subtree && root && subtree_path); - - if ((error = git_buf_sets(&buffer, subtree_path)) == 0) - error = tree_frompath(subtree, root, &buffer, 0); - - git_buf_free(&buffer); - - return error; -} - -static int tree_walk_post( - git_tree *tree, +static int tree_walk( + const git_tree *tree, git_treewalk_cb callback, git_buf *path, - void *payload) + void *payload, + bool preorder) { int error = 0; - unsigned int i; - - for (i = 0; i < tree->entries.length; ++i) { - git_tree_entry *entry = tree->entries.contents[i]; + size_t i; + const git_tree_entry *entry; - if (callback(path->ptr, entry, payload) < 0) - continue; + git_vector_foreach(&tree->entries, i, entry) { + if (preorder) { + error = callback(path->ptr, entry, payload); + if (error > 0) + continue; + if (error < 0) { + giterr_clear(); + return GIT_EUSER; + } + } if (git_tree_entry__is_tree(entry)) { git_tree *subtree; @@ -748,36 +906,41 @@ static int tree_walk_post( if (git_buf_oom(path)) return -1; - if (tree_walk_post(subtree, callback, path, payload) < 0) - return -1; + error = tree_walk(subtree, callback, path, payload, preorder); + if (error != 0) + break; git_buf_truncate(path, path_len); git_tree_free(subtree); } + + if (!preorder && callback(path->ptr, entry, payload) < 0) { + giterr_clear(); + error = GIT_EUSER; + break; + } } - return 0; + return error; } -int git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payload) +int git_tree_walk( + const git_tree *tree, + git_treewalk_mode mode, + git_treewalk_cb callback, + void *payload) { int error = 0; git_buf root_path = GIT_BUF_INIT; - switch (mode) { - case GIT_TREEWALK_POST: - error = tree_walk_post(tree, callback, &root_path, payload); - break; - - case GIT_TREEWALK_PRE: - tree_error("Preorder tree walking is still not implemented"); - return -1; - - default: - giterr_set(GITERR_INVALID, "Invalid walking mode for tree walk"); - return -1; + if (mode != GIT_TREEWALK_POST && mode != GIT_TREEWALK_PRE) { + giterr_set(GITERR_INVALID, "Invalid walking mode for tree walk"); + return -1; } + error = tree_walk( + tree, callback, &root_path, payload, (mode == GIT_TREEWALK_PRE)); + git_buf_free(&root_path); return error; |