tree.con commit Merge branch 'maint' to sync with 1.5.2.1 (8009533)
   1#include "cache.h"
   2#include "tree.h"
   3#include "blob.h"
   4#include "commit.h"
   5#include "tag.h"
   6#include "tree-walk.h"
   7
   8const char *tree_type = "tree";
   9
  10static int read_one_entry(const unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode, int stage)
  11{
  12        int len;
  13        unsigned int size;
  14        struct cache_entry *ce;
  15
  16        if (S_ISDIR(mode))
  17                return READ_TREE_RECURSIVE;
  18
  19        len = strlen(pathname);
  20        size = cache_entry_size(baselen + len);
  21        ce = xcalloc(1, size);
  22
  23        ce->ce_mode = create_ce_mode(mode);
  24        ce->ce_flags = create_ce_flags(baselen + len, stage);
  25        memcpy(ce->name, base, baselen);
  26        memcpy(ce->name + baselen, pathname, len+1);
  27        hashcpy(ce->sha1, sha1);
  28        return add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
  29}
  30
  31static int match_tree_entry(const char *base, int baselen, const char *path, unsigned int mode, const char **paths)
  32{
  33        const char *match;
  34        int pathlen;
  35
  36        if (!paths)
  37                return 1;
  38        pathlen = strlen(path);
  39        while ((match = *paths++) != NULL) {
  40                int matchlen = strlen(match);
  41
  42                if (baselen >= matchlen) {
  43                        /* If it doesn't match, move along... */
  44                        if (strncmp(base, match, matchlen))
  45                                continue;
  46                        /* The base is a subdirectory of a path which was specified. */
  47                        return 1;
  48                }
  49
  50                /* Does the base match? */
  51                if (strncmp(base, match, baselen))
  52                        continue;
  53
  54                match += baselen;
  55                matchlen -= baselen;
  56
  57                if (pathlen > matchlen)
  58                        continue;
  59
  60                if (matchlen > pathlen) {
  61                        if (match[pathlen] != '/')
  62                                continue;
  63                        if (!S_ISDIR(mode))
  64                                continue;
  65                }
  66
  67                if (strncmp(path, match, pathlen))
  68                        continue;
  69
  70                return 1;
  71        }
  72        return 0;
  73}
  74
  75int read_tree_recursive(struct tree *tree,
  76                        const char *base, int baselen,
  77                        int stage, const char **match,
  78                        read_tree_fn_t fn)
  79{
  80        struct tree_desc desc;
  81        struct name_entry entry;
  82
  83        if (parse_tree(tree))
  84                return -1;
  85
  86        init_tree_desc(&desc, tree->buffer, tree->size);
  87
  88        while (tree_entry(&desc, &entry)) {
  89                if (!match_tree_entry(base, baselen, entry.path, entry.mode, match))
  90                        continue;
  91
  92                switch (fn(entry.sha1, base, baselen, entry.path, entry.mode, stage)) {
  93                case 0:
  94                        continue;
  95                case READ_TREE_RECURSIVE:
  96                        break;;
  97                default:
  98                        return -1;
  99                }
 100                if (S_ISDIR(entry.mode)) {
 101                        int retval;
 102                        char *newbase;
 103                        unsigned int pathlen = tree_entry_len(entry.path, entry.sha1);
 104
 105                        newbase = xmalloc(baselen + 1 + pathlen);
 106                        memcpy(newbase, base, baselen);
 107                        memcpy(newbase + baselen, entry.path, pathlen);
 108                        newbase[baselen + pathlen] = '/';
 109                        retval = read_tree_recursive(lookup_tree(entry.sha1),
 110                                                     newbase,
 111                                                     baselen + pathlen + 1,
 112                                                     stage, match, fn);
 113                        free(newbase);
 114                        if (retval)
 115                                return -1;
 116                        continue;
 117                }
 118        }
 119        return 0;
 120}
 121
 122int read_tree(struct tree *tree, int stage, const char **match)
 123{
 124        return read_tree_recursive(tree, "", 0, stage, match, read_one_entry);
 125}
 126
 127struct tree *lookup_tree(const unsigned char *sha1)
 128{
 129        struct object *obj = lookup_object(sha1);
 130        if (!obj)
 131                return create_object(sha1, OBJ_TREE, alloc_tree_node());
 132        if (!obj->type)
 133                obj->type = OBJ_TREE;
 134        if (obj->type != OBJ_TREE) {
 135                error("Object %s is a %s, not a tree",
 136                      sha1_to_hex(sha1), typename(obj->type));
 137                return NULL;
 138        }
 139        return (struct tree *) obj;
 140}
 141
 142/*
 143 * NOTE! Tree refs to external git repositories
 144 * (ie gitlinks) do not count as real references.
 145 *
 146 * You don't have to have those repositories
 147 * available at all, much less have the objects
 148 * accessible from the current repository.
 149 */
 150static void track_tree_refs(struct tree *item)
 151{
 152        int n_refs = 0, i;
 153        struct object_refs *refs;
 154        struct tree_desc desc;
 155        struct name_entry entry;
 156
 157        /* Count how many entries there are.. */
 158        init_tree_desc(&desc, item->buffer, item->size);
 159        while (tree_entry(&desc, &entry)) {
 160                if (S_ISGITLINK(entry.mode))
 161                        continue;
 162                n_refs++;
 163        }
 164
 165        /* Allocate object refs and walk it again.. */
 166        i = 0;
 167        refs = alloc_object_refs(n_refs);
 168        init_tree_desc(&desc, item->buffer, item->size);
 169        while (tree_entry(&desc, &entry)) {
 170                struct object *obj;
 171
 172                if (S_ISGITLINK(entry.mode))
 173                        continue;
 174                if (S_ISDIR(entry.mode))
 175                        obj = &lookup_tree(entry.sha1)->object;
 176                else
 177                        obj = &lookup_blob(entry.sha1)->object;
 178                refs->ref[i++] = obj;
 179        }
 180        set_object_refs(&item->object, refs);
 181}
 182
 183int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
 184{
 185        if (item->object.parsed)
 186                return 0;
 187        item->object.parsed = 1;
 188        item->buffer = buffer;
 189        item->size = size;
 190
 191        if (track_object_refs)
 192                track_tree_refs(item);
 193        return 0;
 194}
 195
 196int parse_tree(struct tree *item)
 197{
 198         enum object_type type;
 199         void *buffer;
 200         unsigned long size;
 201
 202        if (item->object.parsed)
 203                return 0;
 204        buffer = read_sha1_file(item->object.sha1, &type, &size);
 205        if (!buffer)
 206                return error("Could not read %s",
 207                             sha1_to_hex(item->object.sha1));
 208        if (type != OBJ_TREE) {
 209                free(buffer);
 210                return error("Object %s not a tree",
 211                             sha1_to_hex(item->object.sha1));
 212        }
 213        return parse_tree_buffer(item, buffer, size);
 214}
 215
 216struct tree *parse_tree_indirect(const unsigned char *sha1)
 217{
 218        struct object *obj = parse_object(sha1);
 219        do {
 220                if (!obj)
 221                        return NULL;
 222                if (obj->type == OBJ_TREE)
 223                        return (struct tree *) obj;
 224                else if (obj->type == OBJ_COMMIT)
 225                        obj = &(((struct commit *) obj)->tree->object);
 226                else if (obj->type == OBJ_TAG)
 227                        obj = ((struct tag *) obj)->tagged;
 228                else
 229                        return NULL;
 230                if (!obj->parsed)
 231                        parse_object(obj->sha1);
 232        } while (1);
 233}