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 (desc.size) {
 157                n_refs++;
 158                update_tree_entry(&desc);
 159        }
 160
 161        /* Allocate object refs and walk it again.. */
 162        i = 0;
 163        refs = alloc_object_refs(n_refs);
 164        desc.buf = item->buffer;
 165        desc.size = item->size;
 166        while (tree_entry(&desc, &entry)) {
 167                struct object *obj;
 168
 169                if (S_ISDIR(entry.mode))
 170                        obj = &lookup_tree(entry.sha1)->object;
 171                else
 172                        obj = &lookup_blob(entry.sha1)->object;
 173                refs->ref[i++] = obj;
 174        }
 175        set_object_refs(&item->object, refs);
 176}
 177
 178int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
 179{
 180        if (item->object.parsed)
 181                return 0;
 182        item->object.parsed = 1;
 183        item->buffer = buffer;
 184        item->size = size;
 185
 186        if (track_object_refs)
 187                track_tree_refs(item);
 188        return 0;
 189}
 190
 191int parse_tree(struct tree *item)
 192{
 193         char type[20];
 194         void *buffer;
 195         unsigned long size;
 196
 197        if (item->object.parsed)
 198                return 0;
 199        buffer = read_sha1_file(item->object.sha1, type, &size);
 200        if (!buffer)
 201                return error("Could not read %s",
 202                             sha1_to_hex(item->object.sha1));
 203        if (strcmp(type, tree_type)) {
 204                free(buffer);
 205                return error("Object %s not a tree",
 206                             sha1_to_hex(item->object.sha1));
 207        }
 208        return parse_tree_buffer(item, buffer, size);
 209}
 210
 211struct tree *parse_tree_indirect(const unsigned char *sha1)
 212{
 213        struct object *obj = parse_object(sha1);
 214        do {
 215                if (!obj)
 216                        return NULL;
 217                if (obj->type == OBJ_TREE)
 218                        return (struct tree *) obj;
 219                else if (obj->type == OBJ_COMMIT)
 220                        obj = &(((struct commit *) obj)->tree->object);
 221                else if (obj->type == OBJ_TAG)
 222                        obj = ((struct tag *) obj)->tagged;
 223                else
 224                        return NULL;
 225                if (!obj->parsed)
 226                        parse_object(obj->sha1);
 227        } while (1);
 228}