X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=tree.c;h=dabc2e7a2c6f51255914d49f854d82e42ddcab77;hb=98e031f0bb6e857c684e6db24d03d22cfc1a532a;hp=23476da7deb4eaa98a7f872eed4981b274904af7;hpb=d32987be618181db1f435a5c0a1bea85e90c7c7d;p=git.git diff --git a/tree.c b/tree.c index 23476da7..dabc2e7a 100644 --- a/tree.c +++ b/tree.c @@ -9,7 +9,7 @@ static int read_one_entry(unsigned char *sha1, const char *base, int baselen, co { int len = strlen(pathname); unsigned int size = cache_entry_size(baselen + len); - struct cache_entry *ce = malloc(size); + struct cache_entry *ce = xmalloc(size); memset(ce, 0, size); @@ -18,11 +18,56 @@ static int read_one_entry(unsigned char *sha1, const char *base, int baselen, co memcpy(ce->name, base, baselen); memcpy(ce->name + baselen, pathname, len+1); memcpy(ce->sha1, sha1, 20); - return add_cache_entry(ce, 1); + return add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK); +} + +static int match_tree_entry(const char *base, int baselen, const char *path, unsigned int mode, const char **paths) +{ + const char *match; + int pathlen; + + if (!paths) + return 1; + pathlen = strlen(path); + while ((match = *paths++) != NULL) { + int matchlen = strlen(match); + + if (baselen >= matchlen) { + /* If it doesn't match, move along... */ + if (strncmp(base, match, matchlen)) + continue; + /* The base is a subdirectory of a path which was specified. */ + return 1; + } + + /* Does the base match? */ + if (strncmp(base, match, baselen)) + continue; + + match += baselen; + matchlen -= baselen; + + if (pathlen > matchlen) + continue; + + if (matchlen > pathlen) { + if (match[pathlen] != '/') + continue; + if (!S_ISDIR(mode)) + continue; + } + + if (strncmp(path, match, pathlen)) + continue; + + return 1; + } + return 0; } static int read_tree_recursive(void *buffer, unsigned long size, - const char *base, int baselen, int stage) + const char *base, int baselen, + int stage, const char **match) { while (size) { int len = strlen(buffer)+1; @@ -36,23 +81,30 @@ static int read_tree_recursive(void *buffer, unsigned long size, buffer = sha1 + 20; size -= len + 20; + if (!match_tree_entry(base, baselen, path, mode, match)) + continue; + if (S_ISDIR(mode)) { int retval; int pathlen = strlen(path); - char *newbase = malloc(baselen + 1 + pathlen); + char *newbase; void *eltbuf; char elttype[20]; unsigned long eltsize; eltbuf = read_sha1_file(sha1, elttype, &eltsize); - if (!eltbuf || strcmp(elttype, "tree")) + if (!eltbuf || strcmp(elttype, "tree")) { + if (eltbuf) free(eltbuf); return -1; + } + newbase = xmalloc(baselen + 1 + pathlen); memcpy(newbase, base, baselen); memcpy(newbase + baselen, path, pathlen); newbase[baselen + pathlen] = '/'; retval = read_tree_recursive(eltbuf, eltsize, newbase, - baselen + pathlen + 1, stage); + baselen + pathlen + 1, + stage, match); free(eltbuf); free(newbase); if (retval) @@ -65,22 +117,24 @@ static int read_tree_recursive(void *buffer, unsigned long size, return 0; } -int read_tree(void *buffer, unsigned long size, int stage) +int read_tree(void *buffer, unsigned long size, int stage, const char **match) { - return read_tree_recursive(buffer, size, "", 0, stage); + return read_tree_recursive(buffer, size, "", 0, stage, match); } -struct tree *lookup_tree(unsigned char *sha1) +struct tree *lookup_tree(const unsigned char *sha1) { struct object *obj = lookup_object(sha1); if (!obj) { - struct tree *ret = malloc(sizeof(struct tree)); + struct tree *ret = xmalloc(sizeof(struct tree)); memset(ret, 0, sizeof(struct tree)); created_object(sha1, &ret->object); ret->object.type = tree_type; return ret; } - if (obj->parsed && obj->type != tree_type) { + if (!obj->type) + obj->type = tree_type; + if (obj->type != tree_type) { error("Object %s is a %s, not a tree", sha1_to_hex(sha1), obj->type); return NULL; @@ -88,22 +142,14 @@ struct tree *lookup_tree(unsigned char *sha1) return (struct tree *) obj; } -int parse_tree(struct tree *item) +int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size) { - char type[20]; - void *buffer, *bufptr; - unsigned long size; + void *bufptr = buffer; struct tree_entry_list **list_p; + if (item->object.parsed) return 0; item->object.parsed = 1; - buffer = bufptr = read_sha1_file(item->object.sha1, type, &size); - if (!buffer) - return error("Could not read %s", - sha1_to_hex(item->object.sha1)); - if (strcmp(type, tree_type)) - return error("Object %s not a tree", - sha1_to_hex(item->object.sha1)); list_p = &item->entries; while (size) { struct object *obj; @@ -116,17 +162,14 @@ int parse_tree(struct tree *item) sscanf(bufptr, "%o", &mode) != 1) return -1; - entry = malloc(sizeof(struct tree_entry_list)); + entry = xmalloc(sizeof(struct tree_entry_list)); entry->name = strdup(path + 1); - entry->directory = S_ISDIR(mode); - entry->executable = mode & S_IXUSR; + entry->directory = S_ISDIR(mode) != 0; + entry->executable = (mode & S_IXUSR) != 0; + entry->symlink = S_ISLNK(mode) != 0; + entry->mode = mode; entry->next = NULL; - /* Warn about trees that don't do the recursive thing.. */ - if (strchr(path, '/')) { - item->has_full_path = 1; - } - bufptr += len + 20; size -= len + 20; @@ -137,10 +180,34 @@ int parse_tree(struct tree *item) entry->item.blob = lookup_blob(file_sha1); obj = &entry->item.blob->object; } - add_ref(&item->object, obj); - + if (obj) + add_ref(&item->object, obj); + entry->parent = NULL; /* needs to be filled by the user */ *list_p = entry; list_p = &entry->next; } return 0; } + +int parse_tree(struct tree *item) +{ + char type[20]; + void *buffer; + unsigned long size; + int ret; + + if (item->object.parsed) + return 0; + buffer = read_sha1_file(item->object.sha1, type, &size); + if (!buffer) + return error("Could not read %s", + sha1_to_hex(item->object.sha1)); + if (strcmp(type, tree_type)) { + free(buffer); + return error("Object %s not a tree", + sha1_to_hex(item->object.sha1)); + } + ret = parse_tree_buffer(item, buffer, size); + free(buffer); + return ret; +}