3 #include "replace-object.h"
9 #include "object-store.h"
12 unsigned int get_max_object_index(void)
14 return the_repository
->parsed_objects
->obj_hash_size
;
17 struct object
*get_indexed_object(unsigned int idx
)
19 return the_repository
->parsed_objects
->obj_hash
[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 *type_name(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
;
91 if (!the_repository
->parsed_objects
->obj_hash
)
94 first
= i
= hash_obj(sha1
,
95 the_repository
->parsed_objects
->obj_hash_size
);
96 while ((obj
= the_repository
->parsed_objects
->obj_hash
[i
]) != NULL
) {
97 if (!hashcmp(sha1
, obj
->oid
.hash
))
100 if (i
== the_repository
->parsed_objects
->obj_hash_size
)
103 if (obj
&& i
!= first
) {
105 * Move object to where we started to look for it so
106 * that we do not need to walk the hash table the next
107 * time we look for it.
109 SWAP(the_repository
->parsed_objects
->obj_hash
[i
],
110 the_repository
->parsed_objects
->obj_hash
[first
]);
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
120 static void grow_object_hash(struct repository
*r
)
124 * Note that this size must always be power-of-2 to match hash_obj
127 int new_hash_size
= r
->parsed_objects
->obj_hash_size
< 32 ? 32 : 2 * r
->parsed_objects
->obj_hash_size
;
128 struct object
**new_hash
;
130 new_hash
= xcalloc(new_hash_size
, sizeof(struct object
*));
131 for (i
= 0; i
< r
->parsed_objects
->obj_hash_size
; i
++) {
132 struct object
*obj
= r
->parsed_objects
->obj_hash
[i
];
136 insert_obj_hash(obj
, new_hash
, new_hash_size
);
138 free(r
->parsed_objects
->obj_hash
);
139 r
->parsed_objects
->obj_hash
= new_hash
;
140 r
->parsed_objects
->obj_hash_size
= new_hash_size
;
143 void *create_object(struct repository
*r
, const unsigned char *sha1
, void *o
)
145 struct object
*obj
= o
;
149 hashcpy(obj
->oid
.hash
, sha1
);
151 if (r
->parsed_objects
->obj_hash_size
- 1 <= r
->parsed_objects
->nr_objs
* 2)
154 insert_obj_hash(obj
, r
->parsed_objects
->obj_hash
,
155 r
->parsed_objects
->obj_hash_size
);
156 r
->parsed_objects
->nr_objs
++;
160 void *object_as_type(struct object
*obj
, enum object_type type
, int quiet
)
162 if (obj
->type
== type
)
164 else if (obj
->type
== OBJ_NONE
) {
165 if (type
== OBJ_COMMIT
)
166 ((struct commit
*)obj
)->index
= alloc_commit_index(the_repository
);
172 error("object %s is a %s, not a %s",
173 oid_to_hex(&obj
->oid
),
174 type_name(obj
->type
), type_name(type
));
179 struct object
*lookup_unknown_object(const unsigned char *sha1
)
181 struct object
*obj
= lookup_object(sha1
);
183 obj
= create_object(the_repository
, sha1
,
184 alloc_object_node(the_repository
));
188 struct object
*parse_object_buffer(const struct object_id
*oid
, enum object_type type
, unsigned long size
, void *buffer
, int *eaten_p
)
194 if (type
== OBJ_BLOB
) {
195 struct blob
*blob
= lookup_blob(oid
);
197 if (parse_blob_buffer(blob
, buffer
, size
))
201 } else if (type
== OBJ_TREE
) {
202 struct tree
*tree
= lookup_tree(oid
);
206 tree
->object
.parsed
= 0;
207 if (!tree
->object
.parsed
) {
208 if (parse_tree_buffer(tree
, buffer
, size
))
213 } else if (type
== OBJ_COMMIT
) {
214 struct commit
*commit
= lookup_commit(oid
);
216 if (parse_commit_buffer(commit
, buffer
, size
, 1))
218 if (!get_cached_commit_buffer(commit
, NULL
)) {
219 set_commit_buffer(commit
, buffer
, size
);
222 obj
= &commit
->object
;
224 } else if (type
== OBJ_TAG
) {
225 struct tag
*tag
= lookup_tag(oid
);
227 if (parse_tag_buffer(tag
, buffer
, size
))
232 warning("object %s has unknown type id %d", oid_to_hex(oid
), type
);
238 struct object
*parse_object_or_die(const struct object_id
*oid
,
241 struct object
*o
= parse_object(oid
);
245 die(_("unable to parse object: %s"), name
? name
: oid_to_hex(oid
));
248 struct object
*parse_object(const struct object_id
*oid
)
251 enum object_type type
;
253 const struct object_id
*repl
= lookup_replace_object(the_repository
, oid
);
257 obj
= lookup_object(oid
->hash
);
258 if (obj
&& obj
->parsed
)
261 if ((obj
&& obj
->type
== OBJ_BLOB
&& has_object_file(oid
)) ||
262 (!obj
&& has_object_file(oid
) &&
263 oid_object_info(the_repository
, oid
, NULL
) == OBJ_BLOB
)) {
264 if (check_object_signature(repl
, NULL
, 0, NULL
) < 0) {
265 error("sha1 mismatch %s", oid_to_hex(oid
));
268 parse_blob_buffer(lookup_blob(oid
), NULL
, 0);
269 return lookup_object(oid
->hash
);
272 buffer
= read_object_file(oid
, &type
, &size
);
274 if (check_object_signature(repl
, buffer
, size
, type_name(type
)) < 0) {
276 error("sha1 mismatch %s", oid_to_hex(repl
));
280 obj
= parse_object_buffer(oid
, type
, size
, buffer
, &eaten
);
288 struct object_list
*object_list_insert(struct object
*item
,
289 struct object_list
**list_p
)
291 struct object_list
*new_list
= xmalloc(sizeof(struct object_list
));
292 new_list
->item
= item
;
293 new_list
->next
= *list_p
;
298 int object_list_contains(struct object_list
*list
, struct object
*obj
)
301 if (list
->item
== obj
)
309 * A zero-length string to which object_array_entry::name can be
310 * initialized without requiring a malloc/free.
312 static char object_array_slopbuf
[1];
314 void add_object_array_with_path(struct object
*obj
, const char *name
,
315 struct object_array
*array
,
316 unsigned mode
, const char *path
)
318 unsigned nr
= array
->nr
;
319 unsigned alloc
= array
->alloc
;
320 struct object_array_entry
*objects
= array
->objects
;
321 struct object_array_entry
*entry
;
324 alloc
= (alloc
+ 32) * 2;
325 REALLOC_ARRAY(objects
, alloc
);
326 array
->alloc
= alloc
;
327 array
->objects
= objects
;
329 entry
= &objects
[nr
];
334 /* Use our own empty string instead of allocating one: */
335 entry
->name
= object_array_slopbuf
;
337 entry
->name
= xstrdup(name
);
340 entry
->path
= xstrdup(path
);
346 void add_object_array(struct object
*obj
, const char *name
, struct object_array
*array
)
348 add_object_array_with_path(obj
, name
, array
, S_IFINVALID
, NULL
);
352 * Free all memory associated with an entry; the result is
353 * in an unspecified state and should not be examined.
355 static void object_array_release_entry(struct object_array_entry
*ent
)
357 if (ent
->name
!= object_array_slopbuf
)
362 struct object
*object_array_pop(struct object_array
*array
)
369 ret
= array
->objects
[array
->nr
- 1].item
;
370 object_array_release_entry(&array
->objects
[array
->nr
- 1]);
375 void object_array_filter(struct object_array
*array
,
376 object_array_each_func_t want
, void *cb_data
)
378 unsigned nr
= array
->nr
, src
, dst
;
379 struct object_array_entry
*objects
= array
->objects
;
381 for (src
= dst
= 0; src
< nr
; src
++) {
382 if (want(&objects
[src
], cb_data
)) {
384 objects
[dst
] = objects
[src
];
387 object_array_release_entry(&objects
[src
]);
393 void object_array_clear(struct object_array
*array
)
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;
403 * Return true iff array already contains an entry with name.
405 static int contains_name(struct object_array
*array
, const char *name
)
407 unsigned nr
= array
->nr
, i
;
408 struct object_array_entry
*object
= array
->objects
;
410 for (i
= 0; i
< nr
; i
++, object
++)
411 if (!strcmp(object
->name
, name
))
416 void object_array_remove_duplicates(struct object_array
*array
)
418 unsigned nr
= array
->nr
, src
;
419 struct object_array_entry
*objects
= array
->objects
;
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
];
428 object_array_release_entry(&objects
[src
]);
433 void clear_object_flags(unsigned flags
)
437 for (i
=0; i
< the_repository
->parsed_objects
->obj_hash_size
; i
++) {
438 struct object
*obj
= the_repository
->parsed_objects
->obj_hash
[i
];
440 obj
->flags
&= ~flags
;
444 void clear_commit_marks_all(unsigned int flags
)
448 for (i
= 0; i
< the_repository
->parsed_objects
->obj_hash_size
; i
++) {
449 struct object
*obj
= the_repository
->parsed_objects
->obj_hash
[i
];
450 if (obj
&& obj
->type
== OBJ_COMMIT
)
451 obj
->flags
&= ~flags
;
455 struct parsed_object_pool
*parsed_object_pool_new(void)
457 struct parsed_object_pool
*o
= xmalloc(sizeof(*o
));
458 memset(o
, 0, sizeof(*o
));
460 o
->blob_state
= allocate_alloc_state();
461 o
->tree_state
= allocate_alloc_state();
462 o
->commit_state
= allocate_alloc_state();
463 o
->tag_state
= allocate_alloc_state();
464 o
->object_state
= allocate_alloc_state();
469 struct raw_object_store
*raw_object_store_new(void)
471 struct raw_object_store
*o
= xmalloc(sizeof(*o
));
473 memset(o
, 0, sizeof(*o
));
474 INIT_LIST_HEAD(&o
->packed_git_mru
);
478 static void free_alt_odb(struct alternate_object_database
*alt
)
480 strbuf_release(&alt
->scratch
);
481 oid_array_clear(&alt
->loose_objects_cache
);
485 static void free_alt_odbs(struct raw_object_store
*o
)
487 while (o
->alt_odb_list
) {
488 struct alternate_object_database
*next
;
490 next
= o
->alt_odb_list
->next
;
491 free_alt_odb(o
->alt_odb_list
);
492 o
->alt_odb_list
= next
;
496 void raw_object_store_clear(struct raw_object_store
*o
)
498 FREE_AND_NULL(o
->objectdir
);
499 FREE_AND_NULL(o
->alternate_db
);
501 oidmap_free(o
->replace_map
, 1);
502 FREE_AND_NULL(o
->replace_map
);
505 o
->alt_odb_tail
= NULL
;
507 INIT_LIST_HEAD(&o
->packed_git_mru
);
509 o
->packed_git
= NULL
;
512 void parsed_object_pool_clear(struct parsed_object_pool
*o
)
515 * As objects are allocated in slabs (see alloc.c), we do
516 * not need to free each object, but each slab instead.
518 * Before doing so, we need to free any additional memory
519 * the objects may hold.
523 for (i
= 0; i
< o
->obj_hash_size
; i
++) {
524 struct object
*obj
= o
->obj_hash
[i
];
529 if (obj
->type
== OBJ_TREE
)
530 free_tree_buffer((struct tree
*)obj
);
531 else if (obj
->type
== OBJ_COMMIT
)
532 release_commit_memory((struct commit
*)obj
);
533 else if (obj
->type
== OBJ_TAG
)
534 release_tag_memory((struct tag
*)obj
);
537 FREE_AND_NULL(o
->obj_hash
);
538 o
->obj_hash_size
= 0;
540 clear_alloc_state(o
->blob_state
);
541 clear_alloc_state(o
->tree_state
);
542 clear_alloc_state(o
->commit_state
);
543 clear_alloc_state(o
->tag_state
);
544 clear_alloc_state(o
->object_state
);
545 FREE_AND_NULL(o
->blob_state
);
546 FREE_AND_NULL(o
->tree_state
);
547 FREE_AND_NULL(o
->commit_state
);
548 FREE_AND_NULL(o
->tag_state
);
549 FREE_AND_NULL(o
->object_state
);