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