Andrew's git - gitweb.git/blob

   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        desc.buf = tree->buffer;
  87        desc.size = tree->size;
  88
  89        while (tree_entry(&desc, &entry)) {
  90                if (!match_tree_entry(base, baselen, entry.path, entry.mode, match))
  91                        continue;
  92
  93                switch (fn(entry.sha1, base, baselen, entry.path, entry.mode, stage)) {
  94                case 0:
  95                        continue;
  96                case READ_TREE_RECURSIVE:
  97                        break;;
  98                default:
  99                        return -1;
 100                }
 101                if (S_ISDIR(entry.mode)) {
 102                        int retval;
 103                        char *newbase;
 104
 105                        newbase = xmalloc(baselen + 1 + entry.pathlen);
 106                        memcpy(newbase, base, baselen);
 107                        memcpy(newbase + baselen, entry.path, entry.pathlen);
 108                        newbase[baselen + entry.pathlen] = '/';
 109                        retval = read_tree_recursive(lookup_tree(entry.sha1),
 110                                                     newbase,
 111                                                     baselen + entry.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                struct tree *ret = alloc_tree_node();
 132                created_object(sha1, &ret->object);
 133                ret->object.type = OBJ_TREE;
 134                return ret;
 135        }
 136        if (!obj->type)
 137                obj->type = OBJ_TREE;
 138        if (obj->type != OBJ_TREE) {
 139                error("Object %s is a %s, not a tree",
 140                      sha1_to_hex(sha1), typename(obj->type));
 141                return NULL;
 142        }
 143        return (struct tree *) obj;
 144}
 145
 146static void track_tree_refs(struct tree *item)
 147{
 148        int n_refs = 0, i;
 149        struct object_refs *refs;
 150        struct tree_desc desc;
 151        struct name_entry entry;
 152
 153        /* Count how many entries there are.. */
 154        desc.buf = item->buffer;
 155        desc.size = item->size;
 156        while (tree_entry(&desc, &entry))
 157                n_refs++;
 158
 159        /* Allocate object refs and walk it again.. */
 160        i = 0;
 161        refs = alloc_object_refs(n_refs);
 162        desc.buf = item->buffer;
 163        desc.size = item->size;
 164        while (tree_entry(&desc, &entry)) {
 165                struct object *obj;
 166
 167                if (S_ISDIR(entry.mode))
 168                        obj = &lookup_tree(entry.sha1)->object;
 169                else
 170                        obj = &lookup_blob(entry.sha1)->object;
 171                refs->ref[i++] = obj;
 172        }
 173        set_object_refs(&item->object, refs);
 174}
 175
 176int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
 177{
 178        if (item->object.parsed)
 179                return 0;
 180        item->object.parsed = 1;
 181        item->buffer = buffer;
 182        item->size = size;
 183
 184        if (track_object_refs)
 185                track_tree_refs(item);
 186        return 0;
 187}
 188
 189int parse_tree(struct tree *item)
 190{
 191         enum object_type type;
 192         void *buffer;
 193         unsigned long size;
 194
 195        if (item->object.parsed)
 196                return 0;
 197        buffer = read_sha1_file(item->object.sha1, &type, &size);
 198        if (!buffer)
 199                return error("Could not read %s",
 200                             sha1_to_hex(item->object.sha1));
 201        if (type != OBJ_TREE) {
 202                free(buffer);
 203                return error("Object %s not a tree",
 204                             sha1_to_hex(item->object.sha1));
 205        }
 206        return parse_tree_buffer(item, buffer, size);
 207}
 208
 209struct tree *parse_tree_indirect(const unsigned char *sha1)
 210{
 211        struct object *obj = parse_object(sha1);
 212        do {
 213                if (!obj)
 214                        return NULL;
 215                if (obj->type == OBJ_TREE)
 216                        return (struct tree *) obj;
 217                else if (obj->type == OBJ_COMMIT)
 218                        obj = &(((struct commit *) obj)->tree->object);
 219                else if (obj->type == OBJ_TAG)
 220                        obj = ((struct tag *) obj)->tagged;
 221                else
 222                        return NULL;
 223                if (!obj->parsed)
 224                        parse_object(obj->sha1);
 225        } while (1);
 226}