summaryrefslogtreecommitdiff
path: root/tree-walk.c
diff options
context:
space:
mode:
Diffstat (limited to 'tree-walk.c')
-rw-r--r--tree-walk.c178
1 files changed, 135 insertions, 43 deletions
diff --git a/tree-walk.c b/tree-walk.c
index ce27842439..77b37f36fa 100644
--- a/tree-walk.c
+++ b/tree-walk.c
@@ -2,6 +2,7 @@
#include "tree-walk.h"
#include "unpack-trees.h"
#include "dir.h"
+#include "object-store.h"
#include "tree.h"
#include "pathspec.h"
@@ -22,42 +23,72 @@ static const char *get_mode(const char *str, unsigned int *modep)
return str;
}
-static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
+static int decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size, struct strbuf *err)
{
const char *path;
unsigned int mode, len;
+ const unsigned hashsz = the_hash_algo->rawsz;
- if (size < 24 || buf[size - 21])
- die("corrupt tree file");
+ if (size < hashsz + 3 || buf[size - (hashsz + 1)]) {
+ strbuf_addstr(err, _("too-short tree object"));
+ return -1;
+ }
path = get_mode(buf, &mode);
- if (!path || !*path)
- die("corrupt tree file");
+ if (!path) {
+ strbuf_addstr(err, _("malformed mode in tree entry"));
+ return -1;
+ }
+ if (!*path) {
+ strbuf_addstr(err, _("empty filename in tree entry"));
+ return -1;
+ }
len = strlen(path) + 1;
/* Initialize the descriptor entry */
desc->entry.path = path;
desc->entry.mode = canon_mode(mode);
desc->entry.oid = (const struct object_id *)(path + len);
+
+ return 0;
}
-void init_tree_desc(struct tree_desc *desc, const void *buffer, unsigned long size)
+static int init_tree_desc_internal(struct tree_desc *desc, const void *buffer, unsigned long size, struct strbuf *err)
{
desc->buffer = buffer;
desc->size = size;
if (size)
- decode_tree_entry(desc, buffer, size);
+ return decode_tree_entry(desc, buffer, size, err);
+ return 0;
}
-void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
+void init_tree_desc(struct tree_desc *desc, const void *buffer, unsigned long size)
+{
+ struct strbuf err = STRBUF_INIT;
+ if (init_tree_desc_internal(desc, buffer, size, &err))
+ die("%s", err.buf);
+ strbuf_release(&err);
+}
+
+int init_tree_desc_gently(struct tree_desc *desc, const void *buffer, unsigned long size)
+{
+ struct strbuf err = STRBUF_INIT;
+ int result = init_tree_desc_internal(desc, buffer, size, &err);
+ if (result)
+ error("%s", err.buf);
+ strbuf_release(&err);
+ return result;
+}
+
+void *fill_tree_descriptor(struct tree_desc *desc, const struct object_id *oid)
{
unsigned long size = 0;
void *buf = NULL;
- if (sha1) {
- buf = read_object_with_reference(sha1, tree_type, &size, NULL);
+ if (oid) {
+ buf = read_object_with_reference(oid, tree_type, &size, NULL);
if (!buf)
- die("unable to read tree %s", sha1_to_hex(sha1));
+ die("unable to read tree %s", oid_to_hex(oid));
}
init_tree_desc(desc, buf, size);
return buf;
@@ -73,21 +104,44 @@ static void entry_extract(struct tree_desc *t, struct name_entry *a)
*a = t->entry;
}
-void update_tree_entry(struct tree_desc *desc)
+static int update_tree_entry_internal(struct tree_desc *desc, struct strbuf *err)
{
const void *buf = desc->buffer;
- const unsigned char *end = desc->entry.oid->hash + 20;
+ const unsigned char *end = desc->entry.oid->hash + the_hash_algo->rawsz;
unsigned long size = desc->size;
unsigned long len = end - (const unsigned char *)buf;
if (size < len)
- die("corrupt tree file");
+ die(_("too-short tree file"));
buf = end;
size -= len;
desc->buffer = buf;
desc->size = size;
if (size)
- decode_tree_entry(desc, buf, size);
+ return decode_tree_entry(desc, buf, size, err);
+ return 0;
+}
+
+void update_tree_entry(struct tree_desc *desc)
+{
+ struct strbuf err = STRBUF_INIT;
+ if (update_tree_entry_internal(desc, &err))
+ die("%s", err.buf);
+ strbuf_release(&err);
+}
+
+int update_tree_entry_gently(struct tree_desc *desc)
+{
+ struct strbuf err = STRBUF_INIT;
+ if (update_tree_entry_internal(desc, &err)) {
+ error("%s", err.buf);
+ strbuf_release(&err);
+ /* Stop processing this tree after error */
+ desc->size = 0;
+ return -1;
+ }
+ strbuf_release(&err);
+ return 0;
}
int tree_entry(struct tree_desc *desc, struct name_entry *entry)
@@ -100,6 +154,17 @@ int tree_entry(struct tree_desc *desc, struct name_entry *entry)
return 1;
}
+int tree_entry_gently(struct tree_desc *desc, struct name_entry *entry)
+{
+ if (!desc->size)
+ return 0;
+
+ *entry = desc->entry;
+ if (update_tree_entry_gently(desc))
+ return 0;
+ return 1;
+}
+
void setup_traverse_info(struct traverse_info *info, const char *base)
{
int pathlen = strlen(base);
@@ -425,10 +490,10 @@ int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info)
struct dir_state {
void *tree;
unsigned long size;
- unsigned char sha1[20];
+ struct object_id oid;
};
-static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode)
+static int find_tree_entry(struct tree_desc *t, const char *name, struct object_id *result, unsigned *mode)
{
int namelen = strlen(name);
while (t->size) {
@@ -447,7 +512,7 @@ static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char
if (cmp < 0)
break;
if (entrylen == namelen) {
- hashcpy(result, oid->hash);
+ oidcpy(result, oid);
return 0;
}
if (name[entrylen] != '/')
@@ -455,27 +520,27 @@ static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char
if (!S_ISDIR(*mode))
break;
if (++entrylen == namelen) {
- hashcpy(result, oid->hash);
+ oidcpy(result, oid);
return 0;
}
- return get_tree_entry(oid->hash, name + entrylen, result, mode);
+ return get_tree_entry(oid, name + entrylen, result, mode);
}
return -1;
}
-int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned char *sha1, unsigned *mode)
+int get_tree_entry(const struct object_id *tree_oid, const char *name, struct object_id *oid, unsigned *mode)
{
int retval;
void *tree;
unsigned long size;
- unsigned char root[20];
+ struct object_id root;
- tree = read_object_with_reference(tree_sha1, tree_type, &size, root);
+ tree = read_object_with_reference(tree_oid, tree_type, &size, &root);
if (!tree)
return -1;
if (name[0] == '\0') {
- hashcpy(sha1, root);
+ oidcpy(oid, &root);
free(tree);
return 0;
}
@@ -485,7 +550,7 @@ int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned ch
} else {
struct tree_desc t;
init_tree_desc(&t, tree, size);
- retval = find_tree_entry(&t, name, sha1, mode);
+ retval = find_tree_entry(&t, name, oid, mode);
}
free(tree);
return retval;
@@ -513,22 +578,20 @@ int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned ch
* See the code for enum follow_symlink_result for a description of
* the return values.
*/
-enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_sha1, const char *name, unsigned char *result, struct strbuf *result_path, unsigned *mode)
+enum follow_symlinks_result get_tree_entry_follow_symlinks(struct object_id *tree_oid, const char *name, struct object_id *result, struct strbuf *result_path, unsigned *mode)
{
int retval = MISSING_OBJECT;
struct dir_state *parents = NULL;
size_t parents_alloc = 0;
- ssize_t parents_nr = 0;
- unsigned char current_tree_sha1[20];
+ size_t i, parents_nr = 0;
+ struct object_id current_tree_oid;
struct strbuf namebuf = STRBUF_INIT;
struct tree_desc t;
int follows_remaining = GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS;
- int i;
init_tree_desc(&t, NULL, 0UL);
- strbuf_init(result_path, 0);
strbuf_addstr(&namebuf, name);
- hashcpy(current_tree_sha1, tree_sha1);
+ oidcpy(&current_tree_oid, tree_oid);
while (1) {
int find_result;
@@ -537,22 +600,22 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
if (!t.buffer) {
void *tree;
- unsigned char root[20];
+ struct object_id root;
unsigned long size;
- tree = read_object_with_reference(current_tree_sha1,
+ tree = read_object_with_reference(&current_tree_oid,
tree_type, &size,
- root);
+ &root);
if (!tree)
goto done;
ALLOC_GROW(parents, parents_nr + 1, parents_alloc);
parents[parents_nr].tree = tree;
parents[parents_nr].size = size;
- hashcpy(parents[parents_nr].sha1, root);
+ oidcpy(&parents[parents_nr].oid, &root);
parents_nr++;
if (namebuf.buf[0] == '\0') {
- hashcpy(result, root);
+ oidcpy(result, &root);
retval = FOUND;
goto done;
}
@@ -602,21 +665,21 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
/* We could end up here via a symlink to dir/.. */
if (namebuf.buf[0] == '\0') {
- hashcpy(result, parents[parents_nr - 1].sha1);
+ oidcpy(result, &parents[parents_nr - 1].oid);
retval = FOUND;
goto done;
}
/* Look up the first (or only) path component in the tree. */
find_result = find_tree_entry(&t, namebuf.buf,
- current_tree_sha1, mode);
+ &current_tree_oid, mode);
if (find_result) {
goto done;
}
if (S_ISDIR(*mode)) {
if (!remainder) {
- hashcpy(result, current_tree_sha1);
+ oidcpy(result, &current_tree_oid);
retval = FOUND;
goto done;
}
@@ -626,7 +689,7 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
1 + first_slash - namebuf.buf);
} else if (S_ISREG(*mode)) {
if (!remainder) {
- hashcpy(result, current_tree_sha1);
+ oidcpy(result, &current_tree_oid);
retval = FOUND;
} else {
retval = NOT_DIR;
@@ -652,8 +715,8 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
*/
retval = DANGLING_SYMLINK;
- contents = read_sha1_file(current_tree_sha1, &type,
- &link_len);
+ contents = read_object_file(&current_tree_oid, &type,
+ &link_len);
if (!contents)
goto done;
@@ -941,6 +1004,20 @@ static enum interesting do_match(const struct name_entry *entry,
*/
if (ps->recursive && S_ISDIR(entry->mode))
return entry_interesting;
+
+ /*
+ * When matching against submodules with
+ * wildcard characters, ensure that the entry
+ * at least matches up to the first wild
+ * character. More accurate matching can then
+ * be performed in the submodule itself.
+ */
+ if (ps->recurse_submodules &&
+ S_ISGITLINK(entry->mode) &&
+ !ps_strncmp(item, match + baselen,
+ entry->path,
+ item->nowildcard_len - baselen))
+ return entry_interesting;
}
continue;
@@ -977,6 +1054,21 @@ match_wildcards:
strbuf_setlen(base, base_offset + baselen);
return entry_interesting;
}
+
+ /*
+ * When matching against submodules with
+ * wildcard characters, ensure that the entry
+ * at least matches up to the first wild
+ * character. More accurate matching can then
+ * be performed in the submodule itself.
+ */
+ if (ps->recurse_submodules && S_ISGITLINK(entry->mode) &&
+ !ps_strncmp(item, match, base->buf + base_offset,
+ item->nowildcard_len)) {
+ strbuf_setlen(base, base_offset + baselen);
+ return entry_interesting;
+ }
+
strbuf_setlen(base, base_offset + baselen);
/*
@@ -984,7 +1076,7 @@ match_wildcards:
* later on.
* max_depth is ignored but we may consider support it
* in future, see
- * http://thread.gmane.org/gmane.comp.version-control.git/163757/focus=163840
+ * https://public-inbox.org/git/7vmxo5l2g4.fsf@alter.siamese.dyndns.org/
*/
if (ps->recursive && S_ISDIR(entry->mode))
return entry_interesting;
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-13 02:32:05 +0000