7 #include "object-store.h"
9 static struct object
**obj_hash
;
10 static int nr_objs
, obj_hash_size
;
12 unsigned int get_max_object_index(void)
17 struct object
*get_indexed_object(unsigned int idx
)
22 static const char *object_type_strings
[] = {
23 NULL
, /* OBJ_NONE = 0 */
24 "commit", /* OBJ_COMMIT = 1 */
25 "tree", /* OBJ_TREE = 2 */
26 "blob", /* OBJ_BLOB = 3 */
27 "tag", /* OBJ_TAG = 4 */
30 const char *typename(unsigned int type
)
32 if (type
>= ARRAY_SIZE(object_type_strings
))
34 return object_type_strings
[type
];
37 int type_from_string_gently(const char *str
, ssize_t len
, int gentle
)
44 for (i
= 1; i
< ARRAY_SIZE(object_type_strings
); i
++)
45 if (!strncmp(str
, object_type_strings
[i
], len
) &&
46 object_type_strings
[i
][len
] == '\0')
52 die("invalid object type \"%s\"", str
);
56 * Return a numerical hash value between 0 and n-1 for the object with
57 * the specified sha1. n must be a power of 2. Please note that the
58 * return value is *not* consistent across computer architectures.
60 static unsigned int hash_obj(const unsigned char *sha1
, unsigned int n
)
62 return sha1hash(sha1
) & (n
- 1);
66 * Insert obj into the hash table hash, which has length size (which
67 * must be a power of 2). On collisions, simply overflow to the next
70 static void insert_obj_hash(struct object
*obj
, struct object
**hash
, unsigned int size
)
72 unsigned int j
= hash_obj(obj
->oid
.hash
, size
);
83 * Look up the record for the given sha1 in the hash map stored in
84 * obj_hash. Return NULL if it was not found.
86 struct object
*lookup_object(const unsigned char *sha1
)
88 unsigned int i
, first
;
94 first
= i
= hash_obj(sha1
, obj_hash_size
);
95 while ((obj
= obj_hash
[i
]) != NULL
) {
96 if (!hashcmp(sha1
, obj
->oid
.hash
))
99 if (i
== obj_hash_size
)
102 if (obj
&& i
!= first
) {
104 * Move object to where we started to look for it so
105 * that we do not need to walk the hash table the next
106 * time we look for it.
108 SWAP(obj_hash
[i
], obj_hash
[first
]);
114 * Increase the size of the hash map stored in obj_hash to the next
115 * power of 2 (but at least 32). Copy the existing values to the new
118 static void grow_object_hash(void)
122 * Note that this size must always be power-of-2 to match hash_obj
125 int new_hash_size
= obj_hash_size
< 32 ? 32 : 2 * obj_hash_size
;
126 struct object
**new_hash
;
128 new_hash
= xcalloc(new_hash_size
, sizeof(struct object
*));
129 for (i
= 0; i
< obj_hash_size
; i
++) {
130 struct object
*obj
= obj_hash
[i
];
133 insert_obj_hash(obj
, new_hash
, new_hash_size
);
137 obj_hash_size
= new_hash_size
;
140 void *create_object(const unsigned char *sha1
, void *o
)
142 struct object
*obj
= o
;
146 hashcpy(obj
->oid
.hash
, sha1
);
148 if (obj_hash_size
- 1 <= nr_objs
* 2)
151 insert_obj_hash(obj
, obj_hash
, obj_hash_size
);
156 void *object_as_type(struct object
*obj
, enum object_type type
, int quiet
)
158 if (obj
->type
== type
)
160 else if (obj
->type
== OBJ_NONE
) {
161 if (type
== OBJ_COMMIT
)
162 ((struct commit
*)obj
)->index
= alloc_commit_index();
168 error("object %s is a %s, not a %s",
169 oid_to_hex(&obj
->oid
),
170 typename(obj
->type
), typename(type
));
175 struct object
*lookup_unknown_object(const unsigned char *sha1
)
177 struct object
*obj
= lookup_object(sha1
);
179 obj
= create_object(sha1
, alloc_object_node());
183 struct object
*parse_object_buffer(const struct object_id
*oid
, enum object_type type
, unsigned long size
, void *buffer
, int *eaten_p
)
189 if (type
== OBJ_BLOB
) {
190 struct blob
*blob
= lookup_blob(oid
);
192 if (parse_blob_buffer(blob
, buffer
, size
))
196 } else if (type
== OBJ_TREE
) {
197 struct tree
*tree
= lookup_tree(oid
);
201 tree
->object
.parsed
= 0;
202 if (!tree
->object
.parsed
) {
203 if (parse_tree_buffer(tree
, buffer
, size
))
208 } else if (type
== OBJ_COMMIT
) {
209 struct commit
*commit
= lookup_commit(oid
);
211 if (parse_commit_buffer(commit
, buffer
, size
))
213 if (!get_cached_commit_buffer(commit
, NULL
)) {
214 set_commit_buffer(commit
, buffer
, size
);
217 obj
= &commit
->object
;
219 } else if (type
== OBJ_TAG
) {
220 struct tag
*tag
= lookup_tag(oid
);
222 if (parse_tag_buffer(tag
, buffer
, size
))
227 warning("object %s has unknown type id %d", oid_to_hex(oid
), type
);
233 struct object
*parse_object_or_die(const struct object_id
*oid
,
236 struct object
*o
= parse_object(oid
);
240 die(_("unable to parse object: %s"), name
? name
: oid_to_hex(oid
));
243 struct object
*parse_object(const struct object_id
*oid
)
246 enum object_type type
;
248 const unsigned char *repl
= lookup_replace_object(oid
->hash
);
252 obj
= lookup_object(oid
->hash
);
253 if (obj
&& obj
->parsed
)
256 if ((obj
&& obj
->type
== OBJ_BLOB
&& has_object_file(oid
)) ||
257 (!obj
&& has_object_file(oid
) &&
258 sha1_object_info(oid
->hash
, NULL
) == OBJ_BLOB
)) {
259 if (check_sha1_signature(repl
, NULL
, 0, NULL
) < 0) {
260 error("sha1 mismatch %s", oid_to_hex(oid
));
263 parse_blob_buffer(lookup_blob(oid
), NULL
, 0);
264 return lookup_object(oid
->hash
);
267 buffer
= read_sha1_file(oid
->hash
, &type
, &size
);
269 if (check_sha1_signature(repl
, buffer
, size
, typename(type
)) < 0) {
271 error("sha1 mismatch %s", sha1_to_hex(repl
));
275 obj
= parse_object_buffer(oid
, type
, size
, buffer
, &eaten
);
283 struct object_list
*object_list_insert(struct object
*item
,
284 struct object_list
**list_p
)
286 struct object_list
*new_list
= xmalloc(sizeof(struct object_list
));
287 new_list
->item
= item
;
288 new_list
->next
= *list_p
;
293 int object_list_contains(struct object_list
*list
, struct object
*obj
)
296 if (list
->item
== obj
)
304 * A zero-length string to which object_array_entry::name can be
305 * initialized without requiring a malloc/free.
307 static char object_array_slopbuf
[1];
309 void add_object_array_with_path(struct object
*obj
, const char *name
,
310 struct object_array
*array
,
311 unsigned mode
, const char *path
)
313 unsigned nr
= array
->nr
;
314 unsigned alloc
= array
->alloc
;
315 struct object_array_entry
*objects
= array
->objects
;
316 struct object_array_entry
*entry
;
319 alloc
= (alloc
+ 32) * 2;
320 REALLOC_ARRAY(objects
, alloc
);
321 array
->alloc
= alloc
;
322 array
->objects
= objects
;
324 entry
= &objects
[nr
];
329 /* Use our own empty string instead of allocating one: */
330 entry
->name
= object_array_slopbuf
;
332 entry
->name
= xstrdup(name
);
335 entry
->path
= xstrdup(path
);
341 void add_object_array(struct object
*obj
, const char *name
, struct object_array
*array
)
343 add_object_array_with_path(obj
, name
, array
, S_IFINVALID
, NULL
);
347 * Free all memory associated with an entry; the result is
348 * in an unspecified state and should not be examined.
350 static void object_array_release_entry(struct object_array_entry
*ent
)
352 if (ent
->name
!= object_array_slopbuf
)
357 struct object
*object_array_pop(struct object_array
*array
)
364 ret
= array
->objects
[array
->nr
- 1].item
;
365 object_array_release_entry(&array
->objects
[array
->nr
- 1]);
370 void object_array_filter(struct object_array
*array
,
371 object_array_each_func_t want
, void *cb_data
)
373 unsigned nr
= array
->nr
, src
, dst
;
374 struct object_array_entry
*objects
= array
->objects
;
376 for (src
= dst
= 0; src
< nr
; src
++) {
377 if (want(&objects
[src
], cb_data
)) {
379 objects
[dst
] = objects
[src
];
382 object_array_release_entry(&objects
[src
]);
388 void object_array_clear(struct object_array
*array
)
391 for (i
= 0; i
< array
->nr
; i
++)
392 object_array_release_entry(&array
->objects
[i
]);
393 FREE_AND_NULL(array
->objects
);
394 array
->nr
= array
->alloc
= 0;
398 * Return true iff array already contains an entry with name.
400 static int contains_name(struct object_array
*array
, const char *name
)
402 unsigned nr
= array
->nr
, i
;
403 struct object_array_entry
*object
= array
->objects
;
405 for (i
= 0; i
< nr
; i
++, object
++)
406 if (!strcmp(object
->name
, name
))
411 void object_array_remove_duplicates(struct object_array
*array
)
413 unsigned nr
= array
->nr
, src
;
414 struct object_array_entry
*objects
= array
->objects
;
417 for (src
= 0; src
< nr
; src
++) {
418 if (!contains_name(array
, objects
[src
].name
)) {
419 if (src
!= array
->nr
)
420 objects
[array
->nr
] = objects
[src
];
423 object_array_release_entry(&objects
[src
]);
428 void clear_object_flags(unsigned flags
)
432 for (i
=0; i
< obj_hash_size
; i
++) {
433 struct object
*obj
= obj_hash
[i
];
435 obj
->flags
&= ~flags
;
439 void clear_commit_marks_all(unsigned int flags
)
443 for (i
= 0; i
< obj_hash_size
; i
++) {
444 struct object
*obj
= obj_hash
[i
];
445 if (obj
&& obj
->type
== OBJ_COMMIT
)
446 obj
->flags
&= ~flags
;
450 struct raw_object_store
*raw_object_store_new(void)
452 struct raw_object_store
*o
= xmalloc(sizeof(*o
));
454 memset(o
, 0, sizeof(*o
));
458 static void free_alt_odb(struct alternate_object_database
*alt
)
460 strbuf_release(&alt
->scratch
);
461 oid_array_clear(&alt
->loose_objects_cache
);
465 static void free_alt_odbs(struct raw_object_store
*o
)
467 while (o
->alt_odb_list
) {
468 struct alternate_object_database
*next
;
470 next
= o
->alt_odb_list
->next
;
471 free_alt_odb(o
->alt_odb_list
);
472 o
->alt_odb_list
= next
;
476 void raw_object_store_clear(struct raw_object_store
*o
)
478 FREE_AND_NULL(o
->objectdir
);
479 FREE_AND_NULL(o
->alternate_db
);
482 o
->alt_odb_tail
= NULL
;