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