object.c

   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
   8 struct object **objs;
   9 static int nr_objs;
  10 int obj_allocs;
  11
  12 int track_object_refs = 0;
  13
  14 static int hashtable_index(const unsigned char *sha1)
  15 {
  16         unsigned int i;
  17         memcpy(&i, sha1, sizeof(unsigned int));
  18         return (int)(i % obj_allocs);
  19 }
  20
  21 static int find_object(const unsigned char *sha1)
  22 {
  23         int i;
  24
  25         if (!objs)
  26                 return -1;
  27
  28         i = hashtable_index(sha1);
  29         while (objs[i]) {
  30                 if (memcmp(sha1, objs[i]->sha1, 20) == 0)
  31                         return i;
  32                 i++;
  33                 if (i == obj_allocs)
  34                         i = 0;
  35         }
  36         return -1 - i;
  37 }
  38
  39 struct object *lookup_object(const unsigned char *sha1)
  40 {
  41         int pos = find_object(sha1);
  42         if (pos >= 0)
  43                 return objs[pos];
  44         return NULL;
  45 }
  46
  47 void created_object(const unsigned char *sha1, struct object *obj)
  48 {
  49         int pos;
  50
  51         obj->parsed = 0;
  52         memcpy(obj->sha1, sha1, 20);
  53         obj->type = NULL;
  54         obj->refs = NULL;
  55         obj->used = 0;
  56
  57         if (obj_allocs - 1 <= nr_objs * 2) {
  58                 int i, count = obj_allocs;
  59                 obj_allocs = (obj_allocs < 32 ? 32 : 2 * obj_allocs);
  60                 objs = xrealloc(objs, obj_allocs * sizeof(struct object *));
  61                 memset(objs + count, 0, (obj_allocs - count)
  62                                 * sizeof(struct object *));
  63                 for (i = 0; i < obj_allocs; i++)
  64                         if (objs[i]) {
  65                                 int j = find_object(objs[i]->sha1);
  66                                 if (j != i) {
  67                                         j = -1 - j;
  68                                         objs[j] = objs[i];
  69                                         objs[i] = NULL;
  70                                 }
  71                         }
  72         }
  73
  74         pos = find_object(sha1);
  75         if (pos >= 0)
  76                 die("Inserting %s twice\n", sha1_to_hex(sha1));
  77         pos = -pos-1;
  78
  79         objs[pos] = obj;
  80         nr_objs++;
  81 }
  82
  83 struct object_refs *alloc_object_refs(unsigned count)
  84 {
  85         struct object_refs *refs;
  86         size_t size = sizeof(*refs) + count*sizeof(struct object *);
  87
  88         refs = xcalloc(1, size);
  89         refs->count = count;
  90         return refs;
  91 }
  92
  93 static int compare_object_pointers(const void *a, const void *b)
  94 {
  95         const struct object * const *pa = a;
  96         const struct object * const *pb = b;
  97         if (*pa == *pb)
  98                 return 0;
  99         else if (*pa < *pb)
 100                 return -1;
 101         else
 102                 return 1;
 103 }
 104
 105 void set_object_refs(struct object *obj, struct object_refs *refs)
 106 {
 107         unsigned int i, j;
 108
 109         /* Do not install empty list of references */
 110         if (refs->count < 1) {
 111                 free(refs);
 112                 return;
 113         }
 114
 115         /* Sort the list and filter out duplicates */
 116         qsort(refs->ref, refs->count, sizeof(refs->ref[0]),
 117               compare_object_pointers);
 118         for (i = j = 1; i < refs->count; i++) {
 119                 if (refs->ref[i] != refs->ref[i - 1])
 120                         refs->ref[j++] = refs->ref[i];
 121         }
 122         if (j < refs->count) {
 123                 /* Duplicates were found - reallocate list */
 124                 size_t size = sizeof(*refs) + j*sizeof(struct object *);
 125                 refs->count = j;
 126                 refs = xrealloc(refs, size);
 127         }
 128
 129         for (i = 0; i < refs->count; i++)
 130                 refs->ref[i]->used = 1;
 131         obj->refs = refs;
 132 }
 133
 134 void mark_reachable(struct object *obj, unsigned int mask)
 135 {
 136         if (!track_object_refs)
 137                 die("cannot do reachability with object refs turned off");
 138         /* If we've been here already, don't bother */
 139         if (obj->flags & mask)
 140                 return;
 141         obj->flags |= mask;
 142         if (obj->refs) {
 143                 const struct object_refs *refs = obj->refs;
 144                 unsigned i;
 145                 for (i = 0; i < refs->count; i++)
 146                         mark_reachable(refs->ref[i], mask);
 147         }
 148 }
 149
 150 struct object *lookup_object_type(const unsigned char *sha1, const char *type)
 151 {
 152         if (!type) {
 153                 return lookup_unknown_object(sha1);
 154         } else if (!strcmp(type, blob_type)) {
 155                 return &lookup_blob(sha1)->object;
 156         } else if (!strcmp(type, tree_type)) {
 157                 return &lookup_tree(sha1)->object;
 158         } else if (!strcmp(type, commit_type)) {
 159                 return &lookup_commit(sha1)->object;
 160         } else if (!strcmp(type, tag_type)) {
 161                 return &lookup_tag(sha1)->object;
 162         } else {
 163                 error("Unknown type %s", type);
 164                 return NULL;
 165         }
 166 }
 167
 168 union any_object {
 169         struct object object;
 170         struct commit commit;
 171         struct tree tree;
 172         struct blob blob;
 173         struct tag tag;
 174 };
 175
 176 struct object *lookup_unknown_object(const unsigned char *sha1)
 177 {
 178         struct object *obj = lookup_object(sha1);
 179         if (!obj) {
 180                 union any_object *ret = xcalloc(1, sizeof(*ret));
 181                 created_object(sha1, &ret->object);
 182                 ret->object.type = NULL;
 183                 return &ret->object;
 184         }
 185         return obj;
 186 }
 187
 188 struct object *parse_object(const unsigned char *sha1)
 189 {
 190         unsigned long size;
 191         char type[20];
 192         void *buffer = read_sha1_file(sha1, type, &size);
 193         if (buffer) {
 194                 struct object *obj;
 195                 if (check_sha1_signature(sha1, buffer, size, type) < 0)
 196                         printf("sha1 mismatch %s\n", sha1_to_hex(sha1));
 197                 if (!strcmp(type, blob_type)) {
 198                         struct blob *blob = lookup_blob(sha1);
 199                         parse_blob_buffer(blob, buffer, size);
 200                         obj = &blob->object;
 201                 } else if (!strcmp(type, tree_type)) {
 202                         struct tree *tree = lookup_tree(sha1);
 203                         obj = &tree->object;
 204                         if (!tree->object.parsed) {
 205                                 parse_tree_buffer(tree, buffer, size);
 206                                 buffer = NULL;
 207                         }
 208                 } else if (!strcmp(type, commit_type)) {
 209                         struct commit *commit = lookup_commit(sha1);
 210                         parse_commit_buffer(commit, buffer, size);
 211                         if (!commit->buffer) {
 212                                 commit->buffer = buffer;
 213                                 buffer = NULL;
 214                         }
 215                         obj = &commit->object;
 216                 } else if (!strcmp(type, tag_type)) {
 217                         struct tag *tag = lookup_tag(sha1);
 218                         parse_tag_buffer(tag, buffer, size);
 219                         obj = &tag->object;
 220                 } else {
 221                         obj = NULL;
 222                 }
 223                 free(buffer);
 224                 return obj;
 225         }
 226         return NULL;
 227 }
 228
 229 struct object_list *object_list_insert(struct object *item,
 230                                        struct object_list **list_p)
 231 {
 232         struct object_list *new_list = xmalloc(sizeof(struct object_list));
 233         new_list->item = item;
 234         new_list->next = *list_p;
 235         *list_p = new_list;
 236         return new_list;
 237 }
 238
 239 void object_list_append(struct object *item,
 240                         struct object_list **list_p)
 241 {
 242         while (*list_p) {
 243                 list_p = &((*list_p)->next);
 244         }
 245         *list_p = xmalloc(sizeof(struct object_list));
 246         (*list_p)->next = NULL;
 247         (*list_p)->item = item;
 248 }
 249
 250 unsigned object_list_length(struct object_list *list)
 251 {
 252         unsigned ret = 0;
 253         while (list) {
 254                 list = list->next;
 255                 ret++;
 256         }
 257         return ret;
 258 }
 259
 260 int object_list_contains(struct object_list *list, struct object *obj)
 261 {
 262         while (list) {
 263                 if (list->item == obj)
 264                         return 1;
 265                 list = list->next;
 266         }
 267         return 0;
 268 }