object.con commit streaming: convert open_istream to use struct object_id (ef7b519)
   1#include "cache.h"
   2#include "object.h"
   3#include "blob.h"
   4#include "tree.h"
   5#include "commit.h"
   6#include "tag.h"
   7
   8static struct object **obj_hash;
   9static int nr_objs, obj_hash_size;
  10
  11unsigned int get_max_object_index(void)
  12{
  13        return obj_hash_size;
  14}
  15
  16struct object *get_indexed_object(unsigned int idx)
  17{
  18        return obj_hash[idx];
  19}
  20
  21static const char *object_type_strings[] = {
  22        NULL,           /* OBJ_NONE = 0 */
  23        "commit",       /* OBJ_COMMIT = 1 */
  24        "tree",         /* OBJ_TREE = 2 */
  25        "blob",         /* OBJ_BLOB = 3 */
  26        "tag",          /* OBJ_TAG = 4 */
  27};
  28
  29const char *type_name(unsigned int type)
  30{
  31        if (type >= ARRAY_SIZE(object_type_strings))
  32                return NULL;
  33        return object_type_strings[type];
  34}
  35
  36int type_from_string_gently(const char *str, ssize_t len, int gentle)
  37{
  38        int i;
  39
  40        if (len < 0)
  41                len = strlen(str);
  42
  43        for (i = 1; i < ARRAY_SIZE(object_type_strings); i++)
  44                if (!strncmp(str, object_type_strings[i], len) &&
  45                    object_type_strings[i][len] == '\0')
  46                        return i;
  47
  48        if (gentle)
  49                return -1;
  50
  51        die("invalid object type \"%s\"", str);
  52}
  53
  54/*
  55 * Return a numerical hash value between 0 and n-1 for the object with
  56 * the specified sha1.  n must be a power of 2.  Please note that the
  57 * return value is *not* consistent across computer architectures.
  58 */
  59static unsigned int hash_obj(const unsigned char *sha1, unsigned int n)
  60{
  61        return sha1hash(sha1) & (n - 1);
  62}
  63
  64/*
  65 * Insert obj into the hash table hash, which has length size (which
  66 * must be a power of 2).  On collisions, simply overflow to the next
  67 * empty bucket.
  68 */
  69static void insert_obj_hash(struct object *obj, struct object **hash, unsigned int size)
  70{
  71        unsigned int j = hash_obj(obj->oid.hash, size);
  72
  73        while (hash[j]) {
  74                j++;
  75                if (j >= size)
  76                        j = 0;
  77        }
  78        hash[j] = obj;
  79}
  80
  81/*
  82 * Look up the record for the given sha1 in the hash map stored in
  83 * obj_hash.  Return NULL if it was not found.
  84 */
  85struct object *lookup_object(const unsigned char *sha1)
  86{
  87        unsigned int i, first;
  88        struct object *obj;
  89
  90        if (!obj_hash)
  91                return NULL;
  92
  93        first = i = hash_obj(sha1, obj_hash_size);
  94        while ((obj = obj_hash[i]) != NULL) {
  95                if (!hashcmp(sha1, obj->oid.hash))
  96                        break;
  97                i++;
  98                if (i == obj_hash_size)
  99                        i = 0;
 100        }
 101        if (obj && i != first) {
 102                /*
 103                 * Move object to where we started to look for it so
 104                 * that we do not need to walk the hash table the next
 105                 * time we look for it.
 106                 */
 107                SWAP(obj_hash[i], obj_hash[first]);
 108        }
 109        return obj;
 110}
 111
 112/*
 113 * Increase the size of the hash map stored in obj_hash to the next
 114 * power of 2 (but at least 32).  Copy the existing values to the new
 115 * hash map.
 116 */
 117static void grow_object_hash(void)
 118{
 119        int i;
 120        /*
 121         * Note that this size must always be power-of-2 to match hash_obj
 122         * above.
 123         */
 124        int new_hash_size = obj_hash_size < 32 ? 32 : 2 * obj_hash_size;
 125        struct object **new_hash;
 126
 127        new_hash = xcalloc(new_hash_size, sizeof(struct object *));
 128        for (i = 0; i < obj_hash_size; i++) {
 129                struct object *obj = obj_hash[i];
 130                if (!obj)
 131                        continue;
 132                insert_obj_hash(obj, new_hash, new_hash_size);
 133        }
 134        free(obj_hash);
 135        obj_hash = new_hash;
 136        obj_hash_size = new_hash_size;
 137}
 138
 139void *create_object(const unsigned char *sha1, void *o)
 140{
 141        struct object *obj = o;
 142
 143        obj->parsed = 0;
 144        obj->flags = 0;
 145        hashcpy(obj->oid.hash, sha1);
 146
 147        if (obj_hash_size - 1 <= nr_objs * 2)
 148                grow_object_hash();
 149
 150        insert_obj_hash(obj, obj_hash, obj_hash_size);
 151        nr_objs++;
 152        return obj;
 153}
 154
 155void *object_as_type(struct object *obj, enum object_type type, int quiet)
 156{
 157        if (obj->type == type)
 158                return obj;
 159        else if (obj->type == OBJ_NONE) {
 160                if (type == OBJ_COMMIT)
 161                        ((struct commit *)obj)->index = alloc_commit_index();
 162                obj->type = type;
 163                return obj;
 164        }
 165        else {
 166                if (!quiet)
 167                        error("object %s is a %s, not a %s",
 168                              oid_to_hex(&obj->oid),
 169                              type_name(obj->type), type_name(type));
 170                return NULL;
 171        }
 172}
 173
 174struct object *lookup_unknown_object(const unsigned char *sha1)
 175{
 176        struct object *obj = lookup_object(sha1);
 177        if (!obj)
 178                obj = create_object(sha1, alloc_object_node());
 179        return obj;
 180}
 181
 182struct object *parse_object_buffer(const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p)
 183{
 184        struct object *obj;
 185        *eaten_p = 0;
 186
 187        obj = NULL;
 188        if (type == OBJ_BLOB) {
 189                struct blob *blob = lookup_blob(oid);
 190                if (blob) {
 191                        if (parse_blob_buffer(blob, buffer, size))
 192                                return NULL;
 193                        obj = &blob->object;
 194                }
 195        } else if (type == OBJ_TREE) {
 196                struct tree *tree = lookup_tree(oid);
 197                if (tree) {
 198                        obj = &tree->object;
 199                        if (!tree->buffer)
 200                                tree->object.parsed = 0;
 201                        if (!tree->object.parsed) {
 202                                if (parse_tree_buffer(tree, buffer, size))
 203                                        return NULL;
 204                                *eaten_p = 1;
 205                        }
 206                }
 207        } else if (type == OBJ_COMMIT) {
 208                struct commit *commit = lookup_commit(oid);
 209                if (commit) {
 210                        if (parse_commit_buffer(commit, buffer, size))
 211                                return NULL;
 212                        if (!get_cached_commit_buffer(commit, NULL)) {
 213                                set_commit_buffer(commit, buffer, size);
 214                                *eaten_p = 1;
 215                        }
 216                        obj = &commit->object;
 217                }
 218        } else if (type == OBJ_TAG) {
 219                struct tag *tag = lookup_tag(oid);
 220                if (tag) {
 221                        if (parse_tag_buffer(tag, buffer, size))
 222                               return NULL;
 223                        obj = &tag->object;
 224                }
 225        } else {
 226                warning("object %s has unknown type id %d", oid_to_hex(oid), type);
 227                obj = NULL;
 228        }
 229        return obj;
 230}
 231
 232struct object *parse_object_or_die(const struct object_id *oid,
 233                                   const char *name)
 234{
 235        struct object *o = parse_object(oid);
 236        if (o)
 237                return o;
 238
 239        die(_("unable to parse object: %s"), name ? name : oid_to_hex(oid));
 240}
 241
 242struct object *parse_object(const struct object_id *oid)
 243{
 244        unsigned long size;
 245        enum object_type type;
 246        int eaten;
 247        const unsigned char *repl = lookup_replace_object(oid->hash);
 248        void *buffer;
 249        struct object *obj;
 250
 251        obj = lookup_object(oid->hash);
 252        if (obj && obj->parsed)
 253                return obj;
 254
 255        if ((obj && obj->type == OBJ_BLOB && has_object_file(oid)) ||
 256            (!obj && has_object_file(oid) &&
 257             sha1_object_info(oid->hash, NULL) == OBJ_BLOB)) {
 258                struct object_id reploid;
 259                hashcpy(reploid.hash, repl);
 260
 261                if (check_object_signature(&reploid, NULL, 0, NULL) < 0) {
 262                        error("sha1 mismatch %s", oid_to_hex(oid));
 263                        return NULL;
 264                }
 265                parse_blob_buffer(lookup_blob(oid), NULL, 0);
 266                return lookup_object(oid->hash);
 267        }
 268
 269        buffer = read_sha1_file(oid->hash, &type, &size);
 270        if (buffer) {
 271                struct object_id reploid;
 272                hashcpy(reploid.hash, repl);
 273
 274                if (check_object_signature(&reploid, buffer, size, type_name(type)) < 0) {
 275                        free(buffer);
 276                        error("sha1 mismatch %s", sha1_to_hex(repl));
 277                        return NULL;
 278                }
 279
 280                obj = parse_object_buffer(oid, type, size, buffer, &eaten);
 281                if (!eaten)
 282                        free(buffer);
 283                return obj;
 284        }
 285        return NULL;
 286}
 287
 288struct object_list *object_list_insert(struct object *item,
 289                                       struct object_list **list_p)
 290{
 291        struct object_list *new_list = xmalloc(sizeof(struct object_list));
 292        new_list->item = item;
 293        new_list->next = *list_p;
 294        *list_p = new_list;
 295        return new_list;
 296}
 297
 298int object_list_contains(struct object_list *list, struct object *obj)
 299{
 300        while (list) {
 301                if (list->item == obj)
 302                        return 1;
 303                list = list->next;
 304        }
 305        return 0;
 306}
 307
 308/*
 309 * A zero-length string to which object_array_entry::name can be
 310 * initialized without requiring a malloc/free.
 311 */
 312static char object_array_slopbuf[1];
 313
 314void add_object_array_with_path(struct object *obj, const char *name,
 315                                struct object_array *array,
 316                                unsigned mode, const char *path)
 317{
 318        unsigned nr = array->nr;
 319        unsigned alloc = array->alloc;
 320        struct object_array_entry *objects = array->objects;
 321        struct object_array_entry *entry;
 322
 323        if (nr >= alloc) {
 324                alloc = (alloc + 32) * 2;
 325                REALLOC_ARRAY(objects, alloc);
 326                array->alloc = alloc;
 327                array->objects = objects;
 328        }
 329        entry = &objects[nr];
 330        entry->item = obj;
 331        if (!name)
 332                entry->name = NULL;
 333        else if (!*name)
 334                /* Use our own empty string instead of allocating one: */
 335                entry->name = object_array_slopbuf;
 336        else
 337                entry->name = xstrdup(name);
 338        entry->mode = mode;
 339        if (path)
 340                entry->path = xstrdup(path);
 341        else
 342                entry->path = NULL;
 343        array->nr = ++nr;
 344}
 345
 346void add_object_array(struct object *obj, const char *name, struct object_array *array)
 347{
 348        add_object_array_with_path(obj, name, array, S_IFINVALID, NULL);
 349}
 350
 351/*
 352 * Free all memory associated with an entry; the result is
 353 * in an unspecified state and should not be examined.
 354 */
 355static void object_array_release_entry(struct object_array_entry *ent)
 356{
 357        if (ent->name != object_array_slopbuf)
 358                free(ent->name);
 359        free(ent->path);
 360}
 361
 362struct object *object_array_pop(struct object_array *array)
 363{
 364        struct object *ret;
 365
 366        if (!array->nr)
 367                return NULL;
 368
 369        ret = array->objects[array->nr - 1].item;
 370        object_array_release_entry(&array->objects[array->nr - 1]);
 371        array->nr--;
 372        return ret;
 373}
 374
 375void object_array_filter(struct object_array *array,
 376                         object_array_each_func_t want, void *cb_data)
 377{
 378        unsigned nr = array->nr, src, dst;
 379        struct object_array_entry *objects = array->objects;
 380
 381        for (src = dst = 0; src < nr; src++) {
 382                if (want(&objects[src], cb_data)) {
 383                        if (src != dst)
 384                                objects[dst] = objects[src];
 385                        dst++;
 386                } else {
 387                        object_array_release_entry(&objects[src]);
 388                }
 389        }
 390        array->nr = dst;
 391}
 392
 393void object_array_clear(struct object_array *array)
 394{
 395        int i;
 396        for (i = 0; i < array->nr; i++)
 397                object_array_release_entry(&array->objects[i]);
 398        FREE_AND_NULL(array->objects);
 399        array->nr = array->alloc = 0;
 400}
 401
 402/*
 403 * Return true iff array already contains an entry with name.
 404 */
 405static int contains_name(struct object_array *array, const char *name)
 406{
 407        unsigned nr = array->nr, i;
 408        struct object_array_entry *object = array->objects;
 409
 410        for (i = 0; i < nr; i++, object++)
 411                if (!strcmp(object->name, name))
 412                        return 1;
 413        return 0;
 414}
 415
 416void object_array_remove_duplicates(struct object_array *array)
 417{
 418        unsigned nr = array->nr, src;
 419        struct object_array_entry *objects = array->objects;
 420
 421        array->nr = 0;
 422        for (src = 0; src < nr; src++) {
 423                if (!contains_name(array, objects[src].name)) {
 424                        if (src != array->nr)
 425                                objects[array->nr] = objects[src];
 426                        array->nr++;
 427                } else {
 428                        object_array_release_entry(&objects[src]);
 429                }
 430        }
 431}
 432
 433void clear_object_flags(unsigned flags)
 434{
 435        int i;
 436
 437        for (i=0; i < obj_hash_size; i++) {
 438                struct object *obj = obj_hash[i];
 439                if (obj)
 440                        obj->flags &= ~flags;
 441        }
 442}
 443
 444void clear_commit_marks_all(unsigned int flags)
 445{
 446        int i;
 447
 448        for (i = 0; i < obj_hash_size; i++) {
 449                struct object *obj = obj_hash[i];
 450                if (obj && obj->type == OBJ_COMMIT)
 451                        obj->flags &= ~flags;
 452        }
 453}