Merge branch 'bc/object-id'

Conversion from uchar[20] to struct object_id continues.

* bc/object-id: (42 commits)
  merge-one-file: compute empty blob object ID
  add--interactive: compute the empty tree value
  Update shell scripts to compute empty tree object ID
  sha1_file: only expose empty object constants through git_hash_algo
  dir: use the_hash_algo for empty blob object ID
  sequencer: use the_hash_algo for empty tree object ID
  cache-tree: use is_empty_tree_oid
  sha1_file: convert cached object code to struct object_id
  builtin/reset: convert use of EMPTY_TREE_SHA1_BIN
  builtin/receive-pack: convert one use of EMPTY_TREE_SHA1_HEX
  wt-status: convert two uses of EMPTY_TREE_SHA1_HEX
  submodule: convert several uses of EMPTY_TREE_SHA1_HEX
  sequencer: convert one use of EMPTY_TREE_SHA1_HEX
  merge: convert empty tree constant to the_hash_algo
  builtin/merge: switch tree functions to use object_id
  builtin/am: convert uses of EMPTY_TREE_SHA1_BIN to the_hash_algo
  sha1-file: add functions for hex empty tree and blob OIDs
  builtin/receive-pack: avoid hard-coded constants for push certs
  diff: specify abbreviation size in terms of the_hash_algo
  upload-pack: replace use of several hard-coded constants
  ...
This commit is contained in:
Junio C Hamano 2018-05-30 14:04:10 +09:00
commit 42c8ce1c49
46 changed files with 348 additions and 306 deletions

View File

@ -1542,7 +1542,7 @@ static int fall_back_threeway(const struct am_state *state, const char *index_pa
char *their_tree_name; char *their_tree_name;
if (get_oid("HEAD", &our_tree) < 0) if (get_oid("HEAD", &our_tree) < 0)
hashcpy(our_tree.hash, EMPTY_TREE_SHA1_BIN); oidcpy(&our_tree, the_hash_algo->empty_tree);
if (build_fake_ancestor(state, index_path)) if (build_fake_ancestor(state, index_path))
return error("could not build fake ancestor"); return error("could not build fake ancestor");
@ -2042,7 +2042,7 @@ static void am_skip(struct am_state *state)
am_rerere_clear(); am_rerere_clear();
if (get_oid("HEAD", &head)) if (get_oid("HEAD", &head))
hashcpy(head.hash, EMPTY_TREE_SHA1_BIN); oidcpy(&head, the_hash_algo->empty_tree);
if (clean_index(&head, &head)) if (clean_index(&head, &head))
die(_("failed to clean index")); die(_("failed to clean index"));
@ -2105,11 +2105,11 @@ static void am_abort(struct am_state *state)
curr_branch = resolve_refdup("HEAD", 0, &curr_head, NULL); curr_branch = resolve_refdup("HEAD", 0, &curr_head, NULL);
has_curr_head = curr_branch && !is_null_oid(&curr_head); has_curr_head = curr_branch && !is_null_oid(&curr_head);
if (!has_curr_head) if (!has_curr_head)
hashcpy(curr_head.hash, EMPTY_TREE_SHA1_BIN); oidcpy(&curr_head, the_hash_algo->empty_tree);
has_orig_head = !get_oid("ORIG_HEAD", &orig_head); has_orig_head = !get_oid("ORIG_HEAD", &orig_head);
if (!has_orig_head) if (!has_orig_head)
hashcpy(orig_head.hash, EMPTY_TREE_SHA1_BIN); oidcpy(&orig_head, the_hash_algo->empty_tree);
clean_index(&curr_head, &orig_head); clean_index(&curr_head, &orig_head);

View File

@ -66,7 +66,7 @@ static int count_loose(const struct object_id *oid, const char *path, void *data
else { else {
loose_size += on_disk_bytes(st); loose_size += on_disk_bytes(st);
loose++; loose++;
if (verbose && has_sha1_pack(oid->hash)) if (verbose && has_object_pack(oid))
packed_loose++; packed_loose++;
} }
return 0; return 0;

View File

@ -228,7 +228,7 @@ static void check_reachable_object(struct object *obj)
if (!(obj->flags & HAS_OBJ)) { if (!(obj->flags & HAS_OBJ)) {
if (is_promisor_object(&obj->oid)) if (is_promisor_object(&obj->oid))
return; return;
if (has_sha1_pack(obj->oid.hash)) if (has_object_pack(&obj->oid))
return; /* it is in pack - forget about it */ return; /* it is in pack - forget about it */
printf("missing %s %s\n", printable_type(obj), printf("missing %s %s\n", printable_type(obj),
describe_object(obj)); describe_object(obj));

View File

@ -1549,12 +1549,13 @@ static void read_v2_anomalous_offsets(struct packed_git *p,
{ {
const uint32_t *idx1, *idx2; const uint32_t *idx1, *idx2;
uint32_t i; uint32_t i;
const uint32_t hashwords = the_hash_algo->rawsz / sizeof(uint32_t);
/* The address of the 4-byte offset table */ /* The address of the 4-byte offset table */
idx1 = (((const uint32_t *)p->index_data) idx1 = (((const uint32_t *)p->index_data)
+ 2 /* 8-byte header */ + 2 /* 8-byte header */
+ 256 /* fan out */ + 256 /* fan out */
+ 5 * p->num_objects /* 20-byte SHA-1 table */ + hashwords * p->num_objects /* object ID table */
+ p->num_objects /* CRC32 table */ + p->num_objects /* CRC32 table */
); );

View File

@ -280,7 +280,7 @@ out:
return rc; return rc;
} }
static void read_empty(unsigned const char *sha1, int verbose) static void read_empty(const struct object_id *oid, int verbose)
{ {
int i = 0; int i = 0;
const char *args[7]; const char *args[7];
@ -290,15 +290,15 @@ static void read_empty(unsigned const char *sha1, int verbose)
args[i++] = "-v"; args[i++] = "-v";
args[i++] = "-m"; args[i++] = "-m";
args[i++] = "-u"; args[i++] = "-u";
args[i++] = EMPTY_TREE_SHA1_HEX; args[i++] = empty_tree_oid_hex();
args[i++] = sha1_to_hex(sha1); args[i++] = oid_to_hex(oid);
args[i] = NULL; args[i] = NULL;
if (run_command_v_opt(args, RUN_GIT_CMD)) if (run_command_v_opt(args, RUN_GIT_CMD))
die(_("read-tree failed")); die(_("read-tree failed"));
} }
static void reset_hard(unsigned const char *sha1, int verbose) static void reset_hard(const struct object_id *oid, int verbose)
{ {
int i = 0; int i = 0;
const char *args[6]; const char *args[6];
@ -308,7 +308,7 @@ static void reset_hard(unsigned const char *sha1, int verbose)
args[i++] = "-v"; args[i++] = "-v";
args[i++] = "--reset"; args[i++] = "--reset";
args[i++] = "-u"; args[i++] = "-u";
args[i++] = sha1_to_hex(sha1); args[i++] = oid_to_hex(oid);
args[i] = NULL; args[i] = NULL;
if (run_command_v_opt(args, RUN_GIT_CMD)) if (run_command_v_opt(args, RUN_GIT_CMD))
@ -324,7 +324,7 @@ static void restore_state(const struct object_id *head,
if (is_null_oid(stash)) if (is_null_oid(stash))
return; return;
reset_hard(head->hash, 1); reset_hard(head, 1);
args[2] = oid_to_hex(stash); args[2] = oid_to_hex(stash);
@ -1297,7 +1297,7 @@ int cmd_merge(int argc, const char **argv, const char *prefix)
if (remoteheads->next) if (remoteheads->next)
die(_("Can merge only exactly one commit into empty head")); die(_("Can merge only exactly one commit into empty head"));
remote_head_oid = &remoteheads->item->object.oid; remote_head_oid = &remoteheads->item->object.oid;
read_empty(remote_head_oid->hash, 0); read_empty(remote_head_oid, 0);
update_ref("initial pull", "HEAD", remote_head_oid, NULL, 0, update_ref("initial pull", "HEAD", remote_head_oid, NULL, 0,
UPDATE_REFS_DIE_ON_ERR); UPDATE_REFS_DIE_ON_ERR);
goto done; goto done;

View File

@ -279,6 +279,7 @@ static unsigned long write_no_reuse_object(struct hashfile *f, struct object_ent
enum object_type type; enum object_type type;
void *buf; void *buf;
struct git_istream *st = NULL; struct git_istream *st = NULL;
const unsigned hashsz = the_hash_algo->rawsz;
if (!usable_delta) { if (!usable_delta) {
if (oe_type(entry) == OBJ_BLOB && if (oe_type(entry) == OBJ_BLOB &&
@ -335,7 +336,7 @@ static unsigned long write_no_reuse_object(struct hashfile *f, struct object_ent
dheader[pos] = ofs & 127; dheader[pos] = ofs & 127;
while (ofs >>= 7) while (ofs >>= 7)
dheader[--pos] = 128 | (--ofs & 127); dheader[--pos] = 128 | (--ofs & 127);
if (limit && hdrlen + sizeof(dheader) - pos + datalen + 20 >= limit) { if (limit && hdrlen + sizeof(dheader) - pos + datalen + hashsz >= limit) {
if (st) if (st)
close_istream(st); close_istream(st);
free(buf); free(buf);
@ -347,19 +348,19 @@ static unsigned long write_no_reuse_object(struct hashfile *f, struct object_ent
} else if (type == OBJ_REF_DELTA) { } else if (type == OBJ_REF_DELTA) {
/* /*
* Deltas with a base reference contain * Deltas with a base reference contain
* an additional 20 bytes for the base sha1. * additional bytes for the base object ID.
*/ */
if (limit && hdrlen + 20 + datalen + 20 >= limit) { if (limit && hdrlen + hashsz + datalen + hashsz >= limit) {
if (st) if (st)
close_istream(st); close_istream(st);
free(buf); free(buf);
return 0; return 0;
} }
hashwrite(f, header, hdrlen); hashwrite(f, header, hdrlen);
hashwrite(f, DELTA(entry)->idx.oid.hash, 20); hashwrite(f, DELTA(entry)->idx.oid.hash, hashsz);
hdrlen += 20; hdrlen += hashsz;
} else { } else {
if (limit && hdrlen + datalen + 20 >= limit) { if (limit && hdrlen + datalen + hashsz >= limit) {
if (st) if (st)
close_istream(st); close_istream(st);
free(buf); free(buf);
@ -391,6 +392,7 @@ static off_t write_reuse_object(struct hashfile *f, struct object_entry *entry,
unsigned char header[MAX_PACK_OBJECT_HEADER], unsigned char header[MAX_PACK_OBJECT_HEADER],
dheader[MAX_PACK_OBJECT_HEADER]; dheader[MAX_PACK_OBJECT_HEADER];
unsigned hdrlen; unsigned hdrlen;
const unsigned hashsz = the_hash_algo->rawsz;
unsigned long entry_size = SIZE(entry); unsigned long entry_size = SIZE(entry);
if (DELTA(entry)) if (DELTA(entry))
@ -427,7 +429,7 @@ static off_t write_reuse_object(struct hashfile *f, struct object_entry *entry,
dheader[pos] = ofs & 127; dheader[pos] = ofs & 127;
while (ofs >>= 7) while (ofs >>= 7)
dheader[--pos] = 128 | (--ofs & 127); dheader[--pos] = 128 | (--ofs & 127);
if (limit && hdrlen + sizeof(dheader) - pos + datalen + 20 >= limit) { if (limit && hdrlen + sizeof(dheader) - pos + datalen + hashsz >= limit) {
unuse_pack(&w_curs); unuse_pack(&w_curs);
return 0; return 0;
} }
@ -436,16 +438,16 @@ static off_t write_reuse_object(struct hashfile *f, struct object_entry *entry,
hdrlen += sizeof(dheader) - pos; hdrlen += sizeof(dheader) - pos;
reused_delta++; reused_delta++;
} else if (type == OBJ_REF_DELTA) { } else if (type == OBJ_REF_DELTA) {
if (limit && hdrlen + 20 + datalen + 20 >= limit) { if (limit && hdrlen + hashsz + datalen + hashsz >= limit) {
unuse_pack(&w_curs); unuse_pack(&w_curs);
return 0; return 0;
} }
hashwrite(f, header, hdrlen); hashwrite(f, header, hdrlen);
hashwrite(f, DELTA(entry)->idx.oid.hash, 20); hashwrite(f, DELTA(entry)->idx.oid.hash, hashsz);
hdrlen += 20; hdrlen += hashsz;
reused_delta++; reused_delta++;
} else { } else {
if (limit && hdrlen + datalen + 20 >= limit) { if (limit && hdrlen + datalen + hashsz >= limit) {
unuse_pack(&w_curs); unuse_pack(&w_curs);
return 0; return 0;
} }
@ -769,7 +771,7 @@ static off_t write_reused_pack(struct hashfile *f)
die_errno("unable to seek in reused packfile"); die_errno("unable to seek in reused packfile");
if (reuse_packfile_offset < 0) if (reuse_packfile_offset < 0)
reuse_packfile_offset = reuse_packfile->pack_size - 20; reuse_packfile_offset = reuse_packfile->pack_size - the_hash_algo->rawsz;
total = to_write = reuse_packfile_offset - sizeof(struct pack_header); total = to_write = reuse_packfile_offset - sizeof(struct pack_header);
@ -1033,7 +1035,7 @@ static int want_object_in_pack(const struct object_id *oid,
int want; int want;
struct list_head *pos; struct list_head *pos;
if (!exclude && local && has_loose_object_nonlocal(oid->hash)) if (!exclude && local && has_loose_object_nonlocal(oid))
return 0; return 0;
/* /*
@ -1467,7 +1469,7 @@ static void check_object(struct object_entry *entry)
if (reuse_delta && !entry->preferred_base) if (reuse_delta && !entry->preferred_base)
base_ref = use_pack(p, &w_curs, base_ref = use_pack(p, &w_curs,
entry->in_pack_offset + used, NULL); entry->in_pack_offset + used, NULL);
entry->in_pack_header_size = used + 20; entry->in_pack_header_size = used + the_hash_algo->rawsz;
break; break;
case OBJ_OFS_DELTA: case OBJ_OFS_DELTA:
buf = use_pack(p, &w_curs, buf = use_pack(p, &w_curs,
@ -1949,7 +1951,7 @@ static int try_delta(struct unpacked *trg, struct unpacked *src,
/* Now some size filtering heuristics. */ /* Now some size filtering heuristics. */
trg_size = SIZE(trg_entry); trg_size = SIZE(trg_entry);
if (!DELTA(trg_entry)) { if (!DELTA(trg_entry)) {
max_size = trg_size/2 - 20; max_size = trg_size/2 - the_hash_algo->rawsz;
ref_depth = 1; ref_depth = 1;
} else { } else {
max_size = DELTA_SIZE(trg_entry); max_size = DELTA_SIZE(trg_entry);

View File

@ -20,7 +20,7 @@ static int load_all_packs, verbose, alt_odb;
struct llist_item { struct llist_item {
struct llist_item *next; struct llist_item *next;
const unsigned char *sha1; const struct object_id *oid;
}; };
static struct llist { static struct llist {
struct llist_item *front; struct llist_item *front;
@ -90,14 +90,14 @@ static struct llist * llist_copy(struct llist *list)
return ret; return ret;
new_item = ret->front = llist_item_get(); new_item = ret->front = llist_item_get();
new_item->sha1 = list->front->sha1; new_item->oid = list->front->oid;
old_item = list->front->next; old_item = list->front->next;
while (old_item) { while (old_item) {
prev = new_item; prev = new_item;
new_item = llist_item_get(); new_item = llist_item_get();
prev->next = new_item; prev->next = new_item;
new_item->sha1 = old_item->sha1; new_item->oid = old_item->oid;
old_item = old_item->next; old_item = old_item->next;
} }
new_item->next = NULL; new_item->next = NULL;
@ -108,10 +108,10 @@ static struct llist * llist_copy(struct llist *list)
static inline struct llist_item *llist_insert(struct llist *list, static inline struct llist_item *llist_insert(struct llist *list,
struct llist_item *after, struct llist_item *after,
const unsigned char *sha1) const struct object_id *oid)
{ {
struct llist_item *new_item = llist_item_get(); struct llist_item *new_item = llist_item_get();
new_item->sha1 = sha1; new_item->oid = oid;
new_item->next = NULL; new_item->next = NULL;
if (after != NULL) { if (after != NULL) {
@ -131,21 +131,21 @@ static inline struct llist_item *llist_insert(struct llist *list,
} }
static inline struct llist_item *llist_insert_back(struct llist *list, static inline struct llist_item *llist_insert_back(struct llist *list,
const unsigned char *sha1) const struct object_id *oid)
{ {
return llist_insert(list, list->back, sha1); return llist_insert(list, list->back, oid);
} }
static inline struct llist_item *llist_insert_sorted_unique(struct llist *list, static inline struct llist_item *llist_insert_sorted_unique(struct llist *list,
const unsigned char *sha1, struct llist_item *hint) const struct object_id *oid, struct llist_item *hint)
{ {
struct llist_item *prev = NULL, *l; struct llist_item *prev = NULL, *l;
l = (hint == NULL) ? list->front : hint; l = (hint == NULL) ? list->front : hint;
while (l) { while (l) {
int cmp = hashcmp(l->sha1, sha1); int cmp = oidcmp(l->oid, oid);
if (cmp > 0) { /* we insert before this entry */ if (cmp > 0) { /* we insert before this entry */
return llist_insert(list, prev, sha1); return llist_insert(list, prev, oid);
} }
if (!cmp) { /* already exists */ if (!cmp) { /* already exists */
return l; return l;
@ -154,11 +154,11 @@ static inline struct llist_item *llist_insert_sorted_unique(struct llist *list,
l = l->next; l = l->next;
} }
/* insert at the end */ /* insert at the end */
return llist_insert_back(list, sha1); return llist_insert_back(list, oid);
} }
/* returns a pointer to an item in front of sha1 */ /* returns a pointer to an item in front of sha1 */
static inline struct llist_item * llist_sorted_remove(struct llist *list, const unsigned char *sha1, struct llist_item *hint) static inline struct llist_item * llist_sorted_remove(struct llist *list, const struct object_id *oid, struct llist_item *hint)
{ {
struct llist_item *prev, *l; struct llist_item *prev, *l;
@ -166,7 +166,7 @@ redo_from_start:
l = (hint == NULL) ? list->front : hint; l = (hint == NULL) ? list->front : hint;
prev = NULL; prev = NULL;
while (l) { while (l) {
int cmp = hashcmp(l->sha1, sha1); int cmp = oidcmp(l->oid, oid);
if (cmp > 0) /* not in list, since sorted */ if (cmp > 0) /* not in list, since sorted */
return prev; return prev;
if (!cmp) { /* found */ if (!cmp) { /* found */
@ -201,7 +201,7 @@ static void llist_sorted_difference_inplace(struct llist *A,
b = B->front; b = B->front;
while (b) { while (b) {
hint = llist_sorted_remove(A, b->sha1, hint); hint = llist_sorted_remove(A, b->oid, hint);
b = b->next; b = b->next;
} }
} }
@ -252,13 +252,14 @@ static void cmp_two_packs(struct pack_list *p1, struct pack_list *p2)
unsigned long p1_off = 0, p2_off = 0, p1_step, p2_step; unsigned long p1_off = 0, p2_off = 0, p1_step, p2_step;
const unsigned char *p1_base, *p2_base; const unsigned char *p1_base, *p2_base;
struct llist_item *p1_hint = NULL, *p2_hint = NULL; struct llist_item *p1_hint = NULL, *p2_hint = NULL;
const unsigned int hashsz = the_hash_algo->rawsz;
p1_base = p1->pack->index_data; p1_base = p1->pack->index_data;
p2_base = p2->pack->index_data; p2_base = p2->pack->index_data;
p1_base += 256 * 4 + ((p1->pack->index_version < 2) ? 4 : 8); p1_base += 256 * 4 + ((p1->pack->index_version < 2) ? 4 : 8);
p2_base += 256 * 4 + ((p2->pack->index_version < 2) ? 4 : 8); p2_base += 256 * 4 + ((p2->pack->index_version < 2) ? 4 : 8);
p1_step = (p1->pack->index_version < 2) ? 24 : 20; p1_step = hashsz + ((p1->pack->index_version < 2) ? 4 : 0);
p2_step = (p2->pack->index_version < 2) ? 24 : 20; p2_step = hashsz + ((p2->pack->index_version < 2) ? 4 : 0);
while (p1_off < p1->pack->num_objects * p1_step && while (p1_off < p1->pack->num_objects * p1_step &&
p2_off < p2->pack->num_objects * p2_step) p2_off < p2->pack->num_objects * p2_step)
@ -267,9 +268,11 @@ static void cmp_two_packs(struct pack_list *p1, struct pack_list *p2)
/* cmp ~ p1 - p2 */ /* cmp ~ p1 - p2 */
if (cmp == 0) { if (cmp == 0) {
p1_hint = llist_sorted_remove(p1->unique_objects, p1_hint = llist_sorted_remove(p1->unique_objects,
p1_base + p1_off, p1_hint); (const struct object_id *)(p1_base + p1_off),
p1_hint);
p2_hint = llist_sorted_remove(p2->unique_objects, p2_hint = llist_sorted_remove(p2->unique_objects,
p1_base + p1_off, p2_hint); (const struct object_id *)(p1_base + p1_off),
p2_hint);
p1_off += p1_step; p1_off += p1_step;
p2_off += p2_step; p2_off += p2_step;
continue; continue;
@ -359,13 +362,14 @@ static size_t sizeof_union(struct packed_git *p1, struct packed_git *p2)
size_t ret = 0; size_t ret = 0;
unsigned long p1_off = 0, p2_off = 0, p1_step, p2_step; unsigned long p1_off = 0, p2_off = 0, p1_step, p2_step;
const unsigned char *p1_base, *p2_base; const unsigned char *p1_base, *p2_base;
const unsigned int hashsz = the_hash_algo->rawsz;
p1_base = p1->index_data; p1_base = p1->index_data;
p2_base = p2->index_data; p2_base = p2->index_data;
p1_base += 256 * 4 + ((p1->index_version < 2) ? 4 : 8); p1_base += 256 * 4 + ((p1->index_version < 2) ? 4 : 8);
p2_base += 256 * 4 + ((p2->index_version < 2) ? 4 : 8); p2_base += 256 * 4 + ((p2->index_version < 2) ? 4 : 8);
p1_step = (p1->index_version < 2) ? 24 : 20; p1_step = hashsz + ((p1->index_version < 2) ? 4 : 0);
p2_step = (p2->index_version < 2) ? 24 : 20; p2_step = hashsz + ((p2->index_version < 2) ? 4 : 0);
while (p1_off < p1->num_objects * p1_step && while (p1_off < p1->num_objects * p1_step &&
p2_off < p2->num_objects * p2_step) p2_off < p2->num_objects * p2_step)
@ -499,7 +503,7 @@ static void load_all_objects(void)
l = pl->all_objects->front; l = pl->all_objects->front;
while (l) { while (l) {
hint = llist_insert_sorted_unique(all_objects, hint = llist_insert_sorted_unique(all_objects,
l->sha1, hint); l->oid, hint);
l = l->next; l = l->next;
} }
pl = pl->next; pl = pl->next;
@ -558,9 +562,9 @@ static struct pack_list * add_pack(struct packed_git *p)
base = p->index_data; base = p->index_data;
base += 256 * 4 + ((p->index_version < 2) ? 4 : 8); base += 256 * 4 + ((p->index_version < 2) ? 4 : 8);
step = (p->index_version < 2) ? 24 : 20; step = the_hash_algo->rawsz + ((p->index_version < 2) ? 4 : 0);
while (off < p->num_objects * step) { while (off < p->num_objects * step) {
llist_insert_back(l.all_objects, base + off); llist_insert_back(l.all_objects, (const struct object_id *)(base + off));
off += step; off += step;
} }
/* this list will be pruned in cmp_two_packs later */ /* this list will be pruned in cmp_two_packs later */
@ -601,8 +605,8 @@ int cmd_pack_redundant(int argc, const char **argv, const char *prefix)
int i; int i;
struct pack_list *min, *red, *pl; struct pack_list *min, *red, *pl;
struct llist *ignore; struct llist *ignore;
unsigned char *sha1; struct object_id *oid;
char buf[42]; /* 40 byte sha1 + \n + \0 */ char buf[GIT_MAX_HEXSZ + 2]; /* hex hash + \n + \0 */
if (argc == 2 && !strcmp(argv[1], "-h")) if (argc == 2 && !strcmp(argv[1], "-h"))
usage(pack_redundant_usage); usage(pack_redundant_usage);
@ -650,10 +654,10 @@ int cmd_pack_redundant(int argc, const char **argv, const char *prefix)
llist_init(&ignore); llist_init(&ignore);
if (!isatty(0)) { if (!isatty(0)) {
while (fgets(buf, sizeof(buf), stdin)) { while (fgets(buf, sizeof(buf), stdin)) {
sha1 = xmalloc(20); oid = xmalloc(sizeof(*oid));
if (get_sha1_hex(buf, sha1)) if (get_oid_hex(buf, oid))
die("Bad sha1 on stdin: %s", buf); die("Bad object ID on stdin: %s", buf);
llist_insert_sorted_unique(ignore, sha1, NULL); llist_insert_sorted_unique(ignore, oid, NULL);
} }
} }
llist_sorted_difference_inplace(all_objects, ignore); llist_sorted_difference_inplace(all_objects, ignore);

View File

@ -25,7 +25,7 @@ static int prune_object(const struct object_id *oid, const char *path,
{ {
int *opts = data; int *opts = data;
if (!has_sha1_pack(oid->hash)) if (!has_object_pack(oid))
return 0; return 0;
if (*opts & PRUNE_PACKED_DRY_RUN) if (*opts & PRUNE_PACKED_DRY_RUN)

View File

@ -454,21 +454,21 @@ static void hmac_sha1(unsigned char *out,
/* RFC 2104 2. (6) & (7) */ /* RFC 2104 2. (6) & (7) */
git_SHA1_Init(&ctx); git_SHA1_Init(&ctx);
git_SHA1_Update(&ctx, k_opad, sizeof(k_opad)); git_SHA1_Update(&ctx, k_opad, sizeof(k_opad));
git_SHA1_Update(&ctx, out, 20); git_SHA1_Update(&ctx, out, GIT_SHA1_RAWSZ);
git_SHA1_Final(out, &ctx); git_SHA1_Final(out, &ctx);
} }
static char *prepare_push_cert_nonce(const char *path, timestamp_t stamp) static char *prepare_push_cert_nonce(const char *path, timestamp_t stamp)
{ {
struct strbuf buf = STRBUF_INIT; struct strbuf buf = STRBUF_INIT;
unsigned char sha1[20]; unsigned char sha1[GIT_SHA1_RAWSZ];
strbuf_addf(&buf, "%s:%"PRItime, path, stamp); strbuf_addf(&buf, "%s:%"PRItime, path, stamp);
hmac_sha1(sha1, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));; hmac_sha1(sha1, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));;
strbuf_release(&buf); strbuf_release(&buf);
/* RFC 2104 5. HMAC-SHA1-80 */ /* RFC 2104 5. HMAC-SHA1-80 */
strbuf_addf(&buf, "%"PRItime"-%.*s", stamp, 20, sha1_to_hex(sha1)); strbuf_addf(&buf, "%"PRItime"-%.*s", stamp, GIT_SHA1_HEXSZ, sha1_to_hex(sha1));
return strbuf_detach(&buf, NULL); return strbuf_detach(&buf, NULL);
} }
@ -968,7 +968,7 @@ static const char *push_to_deploy(unsigned char *sha1,
return "Working directory has unstaged changes"; return "Working directory has unstaged changes";
/* diff-index with either HEAD or an empty tree */ /* diff-index with either HEAD or an empty tree */
diff_index[4] = head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX; diff_index[4] = head_has_history() ? "HEAD" : empty_tree_oid_hex();
child_process_init(&child); child_process_init(&child);
child.argv = diff_index; child.argv = diff_index;

View File

@ -314,7 +314,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
unborn = !strcmp(rev, "HEAD") && get_oid("HEAD", &oid); unborn = !strcmp(rev, "HEAD") && get_oid("HEAD", &oid);
if (unborn) { if (unborn) {
/* reset on unborn branch: treat as reset to empty tree */ /* reset on unborn branch: treat as reset to empty tree */
hashcpy(oid.hash, EMPTY_TREE_SHA1_BIN); oidcpy(&oid, the_hash_algo->empty_tree);
} else if (!pathspec.nr) { } else if (!pathspec.nr) {
struct commit *commit; struct commit *commit;
if (get_oid_committish(rev, &oid)) if (get_oid_committish(rev, &oid))

View File

@ -887,8 +887,8 @@ int cmd_rev_parse(int argc, const char **argv, const char *prefix)
if (read_cache() < 0) if (read_cache() < 0)
die(_("Could not read the index")); die(_("Could not read the index"));
if (the_index.split_index) { if (the_index.split_index) {
const unsigned char *sha1 = the_index.split_index->base_sha1; const struct object_id *oid = &the_index.split_index->base_oid;
const char *path = git_path("sharedindex.%s", sha1_to_hex(sha1)); const char *path = git_path("sharedindex.%s", oid_to_hex(oid));
strbuf_reset(&buf); strbuf_reset(&buf);
puts(relative_path(path, prefix, &buf)); puts(relative_path(path, prefix, &buf));
} }

View File

@ -385,7 +385,7 @@ static int update_one(struct cache_tree *it,
/* /*
* "sub" can be an empty tree if all subentries are i-t-a. * "sub" can be an empty tree if all subentries are i-t-a.
*/ */
if (contains_ita && !oidcmp(oid, &empty_tree_oid)) if (contains_ita && is_empty_tree_oid(oid))
continue; continue;
strbuf_grow(&buffer, entlen + 100); strbuf_grow(&buffer, entlen + 100);
@ -523,7 +523,7 @@ static struct cache_tree *read_one(const char **buffer, unsigned long *size_p)
if (0 <= it->entry_count) { if (0 <= it->entry_count) {
if (size < rawsz) if (size < rawsz)
goto free_return; goto free_return;
memcpy(it->oid.hash, (const unsigned char*)buf, rawsz); oidread(&it->oid, (const unsigned char *)buf);
buf += rawsz; buf += rawsz;
size -= rawsz; size -= rawsz;
} }

28
cache.h
View File

@ -324,7 +324,7 @@ struct index_state {
drop_cache_tree : 1; drop_cache_tree : 1;
struct hashmap name_hash; struct hashmap name_hash;
struct hashmap dir_hash; struct hashmap dir_hash;
unsigned char sha1[20]; struct object_id oid;
struct untracked_cache *untracked; struct untracked_cache *untracked;
uint64_t fsmonitor_last_update; uint64_t fsmonitor_last_update;
struct ewah_bitmap *fsmonitor_dirty; struct ewah_bitmap *fsmonitor_dirty;
@ -1017,21 +1017,10 @@ static inline void oidclr(struct object_id *oid)
memset(oid->hash, 0, GIT_MAX_RAWSZ); memset(oid->hash, 0, GIT_MAX_RAWSZ);
} }
static inline void oidread(struct object_id *oid, const unsigned char *hash)
#define EMPTY_TREE_SHA1_HEX \ {
"4b825dc642cb6eb9a060e54bf8d69288fbee4904" memcpy(oid->hash, hash, the_hash_algo->rawsz);
#define EMPTY_TREE_SHA1_BIN_LITERAL \ }
"\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60" \
"\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04"
extern const struct object_id empty_tree_oid;
#define EMPTY_TREE_SHA1_BIN (empty_tree_oid.hash)
#define EMPTY_BLOB_SHA1_HEX \
"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"
#define EMPTY_BLOB_SHA1_BIN_LITERAL \
"\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b" \
"\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91"
extern const struct object_id empty_blob_oid;
static inline int is_empty_blob_sha1(const unsigned char *sha1) static inline int is_empty_blob_sha1(const unsigned char *sha1)
{ {
@ -1053,6 +1042,9 @@ static inline int is_empty_tree_oid(const struct object_id *oid)
return !oidcmp(oid, the_hash_algo->empty_tree); return !oidcmp(oid, the_hash_algo->empty_tree);
} }
const char *empty_tree_oid_hex(void);
const char *empty_blob_oid_hex(void);
/* set default permissions by passing mode arguments to open(2) */ /* set default permissions by passing mode arguments to open(2) */
int git_mkstemps_mode(char *pattern, int suffix_len, int mode); int git_mkstemps_mode(char *pattern, int suffix_len, int mode);
int git_mkstemp_mode(char *pattern, int mode); int git_mkstemp_mode(char *pattern, int mode);
@ -1268,7 +1260,7 @@ extern int has_object_file_with_flags(const struct object_id *oid, int flags);
* with the specified name. This function does not respect replace * with the specified name. This function does not respect replace
* references. * references.
*/ */
extern int has_loose_object_nonlocal(const unsigned char *sha1); extern int has_loose_object_nonlocal(const struct object_id *oid);
extern void assert_oid_type(const struct object_id *oid, enum object_type expect); extern void assert_oid_type(const struct object_id *oid, enum object_type expect);
@ -1299,7 +1291,6 @@ static inline int hex2chr(const char *s)
#define FALLBACK_DEFAULT_ABBREV 7 #define FALLBACK_DEFAULT_ABBREV 7
struct object_context { struct object_context {
unsigned char tree[20];
unsigned mode; unsigned mode;
/* /*
* symlink_path is only used by get_tree_entry_follow_symlinks, * symlink_path is only used by get_tree_entry_follow_symlinks,
@ -1566,7 +1557,6 @@ struct pack_window {
struct pack_entry { struct pack_entry {
off_t offset; off_t offset;
unsigned char sha1[20];
struct packed_git *p; struct packed_git *p;
}; };

View File

@ -358,7 +358,7 @@ int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long s
if (tail <= bufptr + tree_entry_len + 1 || memcmp(bufptr, "tree ", 5) || if (tail <= bufptr + tree_entry_len + 1 || memcmp(bufptr, "tree ", 5) ||
bufptr[tree_entry_len] != '\n') bufptr[tree_entry_len] != '\n')
return error("bogus commit object %s", oid_to_hex(&item->object.oid)); return error("bogus commit object %s", oid_to_hex(&item->object.oid));
if (get_sha1_hex(bufptr + 5, parent.hash) < 0) if (get_oid_hex(bufptr + 5, &parent) < 0)
return error("bad tree pointer in commit %s", return error("bad tree pointer in commit %s",
oid_to_hex(&item->object.oid)); oid_to_hex(&item->object.oid));
item->maybe_tree = lookup_tree(&parent); item->maybe_tree = lookup_tree(&parent);
@ -370,7 +370,7 @@ int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long s
struct commit *new_parent; struct commit *new_parent;
if (tail <= bufptr + parent_entry_len + 1 || if (tail <= bufptr + parent_entry_len + 1 ||
get_sha1_hex(bufptr + 7, parent.hash) || get_oid_hex(bufptr + 7, &parent) ||
bufptr[parent_entry_len] != '\n') bufptr[parent_entry_len] != '\n')
return error("bad parents in commit %s", oid_to_hex(&item->object.oid)); return error("bad parents in commit %s", oid_to_hex(&item->object.oid));
bufptr += parent_entry_len + 1; bufptr += parent_entry_len + 1;

20
diff.c
View File

@ -3472,7 +3472,7 @@ static int reuse_worktree_file(const char *name, const struct object_id *oid, in
* objects however would tend to be slower as they need * objects however would tend to be slower as they need
* to be individually opened and inflated. * to be individually opened and inflated.
*/ */
if (!FAST_WORKING_DIRECTORY && !want_file && has_sha1_pack(oid->hash)) if (!FAST_WORKING_DIRECTORY && !want_file && has_object_pack(oid))
return 0; return 0;
/* /*
@ -3898,13 +3898,14 @@ static void fill_metainfo(struct strbuf *msg,
*must_show_header = 0; *must_show_header = 0;
} }
if (one && two && oidcmp(&one->oid, &two->oid)) { if (one && two && oidcmp(&one->oid, &two->oid)) {
int abbrev = o->flags.full_index ? 40 : DEFAULT_ABBREV; const unsigned hexsz = the_hash_algo->hexsz;
int abbrev = o->flags.full_index ? hexsz : DEFAULT_ABBREV;
if (o->flags.binary) { if (o->flags.binary) {
mmfile_t mf; mmfile_t mf;
if ((!fill_mmfile(&mf, one) && diff_filespec_is_binary(one)) || if ((!fill_mmfile(&mf, one) && diff_filespec_is_binary(one)) ||
(!fill_mmfile(&mf, two) && diff_filespec_is_binary(two))) (!fill_mmfile(&mf, two) && diff_filespec_is_binary(two)))
abbrev = 40; abbrev = hexsz;
} }
strbuf_addf(msg, "%s%sindex %s..%s", line_prefix, set, strbuf_addf(msg, "%s%sindex %s..%s", line_prefix, set,
diff_abbrev_oid(&one->oid, abbrev), diff_abbrev_oid(&one->oid, abbrev),
@ -4139,6 +4140,11 @@ void diff_setup_done(struct diff_options *options)
DIFF_FORMAT_NAME_STATUS | DIFF_FORMAT_NAME_STATUS |
DIFF_FORMAT_CHECKDIFF | DIFF_FORMAT_CHECKDIFF |
DIFF_FORMAT_NO_OUTPUT; DIFF_FORMAT_NO_OUTPUT;
/*
* This must be signed because we're comparing against a potentially
* negative value.
*/
const int hexsz = the_hash_algo->hexsz;
if (options->set_default) if (options->set_default)
options->set_default(options); options->set_default(options);
@ -4219,8 +4225,8 @@ void diff_setup_done(struct diff_options *options)
*/ */
read_cache(); read_cache();
} }
if (40 < options->abbrev) if (hexsz < options->abbrev)
options->abbrev = 40; /* full */ options->abbrev = hexsz; /* full */
/* /*
* It does not make sense to show the first hit we happened * It does not make sense to show the first hit we happened
@ -4798,8 +4804,8 @@ int diff_opt_parse(struct diff_options *options,
options->abbrev = strtoul(arg, NULL, 10); options->abbrev = strtoul(arg, NULL, 10);
if (options->abbrev < MINIMUM_ABBREV) if (options->abbrev < MINIMUM_ABBREV)
options->abbrev = MINIMUM_ABBREV; options->abbrev = MINIMUM_ABBREV;
else if (40 < options->abbrev) else if (the_hash_algo->hexsz < options->abbrev)
options->abbrev = 40; options->abbrev = the_hash_algo->hexsz;
} }
else if ((argcount = parse_long_opt("src-prefix", av, &optarg))) { else if ((argcount = parse_long_opt("src-prefix", av, &optarg))) {
options->a_prefix = optarg; options->a_prefix = optarg;

25
dir.c
View File

@ -829,7 +829,7 @@ static int add_excludes(const char *fname, const char *base, int baselen,
if (size == 0) { if (size == 0) {
if (oid_stat) { if (oid_stat) {
fill_stat_data(&oid_stat->stat, &st); fill_stat_data(&oid_stat->stat, &st);
oidcpy(&oid_stat->oid, &empty_blob_oid); oidcpy(&oid_stat->oid, the_hash_algo->empty_blob);
oid_stat->valid = 1; oid_stat->valid = 1;
} }
close(fd); close(fd);
@ -1241,11 +1241,11 @@ static void prep_exclude(struct dir_struct *dir,
(!untracked || !untracked->valid || (!untracked || !untracked->valid ||
/* /*
* .. and .gitignore does not exist before * .. and .gitignore does not exist before
* (i.e. null exclude_sha1). Then we can skip * (i.e. null exclude_oid). Then we can skip
* loading .gitignore, which would result in * loading .gitignore, which would result in
* ENOENT anyway. * ENOENT anyway.
*/ */
!is_null_sha1(untracked->exclude_sha1))) { !is_null_oid(&untracked->exclude_oid))) {
/* /*
* dir->basebuf gets reused by the traversal, but we * dir->basebuf gets reused by the traversal, but we
* need fname to remain unchanged to ensure the src * need fname to remain unchanged to ensure the src
@ -1276,9 +1276,9 @@ static void prep_exclude(struct dir_struct *dir,
* order, though, if you do that. * order, though, if you do that.
*/ */
if (untracked && if (untracked &&
hashcmp(oid_stat.oid.hash, untracked->exclude_sha1)) { oidcmp(&oid_stat.oid, &untracked->exclude_oid)) {
invalidate_gitignore(dir->untracked, untracked); invalidate_gitignore(dir->untracked, untracked);
hashcpy(untracked->exclude_sha1, oid_stat.oid.hash); oidcpy(&untracked->exclude_oid, &oid_stat.oid);
} }
dir->exclude_stack = stk; dir->exclude_stack = stk;
current = stk->baselen; current = stk->baselen;
@ -2623,9 +2623,10 @@ static void write_one_dir(struct untracked_cache_dir *untracked,
stat_data_to_disk(&stat_data, &untracked->stat_data); stat_data_to_disk(&stat_data, &untracked->stat_data);
strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data)); strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data));
} }
if (!is_null_sha1(untracked->exclude_sha1)) { if (!is_null_oid(&untracked->exclude_oid)) {
ewah_set(wd->sha1_valid, i); ewah_set(wd->sha1_valid, i);
strbuf_add(&wd->sb_sha1, untracked->exclude_sha1, 20); strbuf_add(&wd->sb_sha1, untracked->exclude_oid.hash,
the_hash_algo->rawsz);
} }
intlen = encode_varint(untracked->untracked_nr, intbuf); intlen = encode_varint(untracked->untracked_nr, intbuf);
@ -2826,16 +2827,16 @@ static void read_stat(size_t pos, void *cb)
ud->valid = 1; ud->valid = 1;
} }
static void read_sha1(size_t pos, void *cb) static void read_oid(size_t pos, void *cb)
{ {
struct read_data *rd = cb; struct read_data *rd = cb;
struct untracked_cache_dir *ud = rd->ucd[pos]; struct untracked_cache_dir *ud = rd->ucd[pos];
if (rd->data + 20 > rd->end) { if (rd->data + the_hash_algo->rawsz > rd->end) {
rd->data = rd->end + 1; rd->data = rd->end + 1;
return; return;
} }
hashcpy(ud->exclude_sha1, rd->data); hashcpy(ud->exclude_oid.hash, rd->data);
rd->data += 20; rd->data += the_hash_algo->rawsz;
} }
static void load_oid_stat(struct oid_stat *oid_stat, const unsigned char *data, static void load_oid_stat(struct oid_stat *oid_stat, const unsigned char *data,
@ -2918,7 +2919,7 @@ struct untracked_cache *read_untracked_extension(const void *data, unsigned long
ewah_each_bit(rd.check_only, set_check_only, &rd); ewah_each_bit(rd.check_only, set_check_only, &rd);
rd.data = next + len; rd.data = next + len;
ewah_each_bit(rd.valid, read_stat, &rd); ewah_each_bit(rd.valid, read_stat, &rd);
ewah_each_bit(rd.sha1_valid, read_sha1, &rd); ewah_each_bit(rd.sha1_valid, read_oid, &rd);
next = rd.data; next = rd.data;
done: done:

5
dir.h
View File

@ -3,6 +3,7 @@
/* See Documentation/technical/api-directory-listing.txt */ /* See Documentation/technical/api-directory-listing.txt */
#include "cache.h"
#include "strbuf.h" #include "strbuf.h"
struct dir_entry { struct dir_entry {
@ -118,8 +119,8 @@ struct untracked_cache_dir {
/* all data except 'dirs' in this struct are good */ /* all data except 'dirs' in this struct are good */
unsigned int valid : 1; unsigned int valid : 1;
unsigned int recurse : 1; unsigned int recurse : 1;
/* null SHA-1 means this directory does not have .gitignore */ /* null object ID means this directory does not have .gitignore */
unsigned char exclude_sha1[20]; struct object_id exclude_oid;
char name[FLEX_ARRAY]; char name[FLEX_ARRAY];
}; };

20
fsck.c
View File

@ -734,30 +734,31 @@ static int fsck_ident(const char **ident, struct object *obj, struct fsck_option
static int fsck_commit_buffer(struct commit *commit, const char *buffer, static int fsck_commit_buffer(struct commit *commit, const char *buffer,
unsigned long size, struct fsck_options *options) unsigned long size, struct fsck_options *options)
{ {
unsigned char tree_sha1[20], sha1[20]; struct object_id tree_oid, oid;
struct commit_graft *graft; struct commit_graft *graft;
unsigned parent_count, parent_line_count = 0, author_count; unsigned parent_count, parent_line_count = 0, author_count;
int err; int err;
const char *buffer_begin = buffer; const char *buffer_begin = buffer;
const char *p;
if (verify_headers(buffer, size, &commit->object, options)) if (verify_headers(buffer, size, &commit->object, options))
return -1; return -1;
if (!skip_prefix(buffer, "tree ", &buffer)) if (!skip_prefix(buffer, "tree ", &buffer))
return report(options, &commit->object, FSCK_MSG_MISSING_TREE, "invalid format - expected 'tree' line"); return report(options, &commit->object, FSCK_MSG_MISSING_TREE, "invalid format - expected 'tree' line");
if (get_sha1_hex(buffer, tree_sha1) || buffer[40] != '\n') { if (parse_oid_hex(buffer, &tree_oid, &p) || *p != '\n') {
err = report(options, &commit->object, FSCK_MSG_BAD_TREE_SHA1, "invalid 'tree' line format - bad sha1"); err = report(options, &commit->object, FSCK_MSG_BAD_TREE_SHA1, "invalid 'tree' line format - bad sha1");
if (err) if (err)
return err; return err;
} }
buffer += 41; buffer = p + 1;
while (skip_prefix(buffer, "parent ", &buffer)) { while (skip_prefix(buffer, "parent ", &buffer)) {
if (get_sha1_hex(buffer, sha1) || buffer[40] != '\n') { if (parse_oid_hex(buffer, &oid, &p) || *p != '\n') {
err = report(options, &commit->object, FSCK_MSG_BAD_PARENT_SHA1, "invalid 'parent' line format - bad sha1"); err = report(options, &commit->object, FSCK_MSG_BAD_PARENT_SHA1, "invalid 'parent' line format - bad sha1");
if (err) if (err)
return err; return err;
} }
buffer += 41; buffer = p + 1;
parent_line_count++; parent_line_count++;
} }
graft = lookup_commit_graft(&commit->object.oid); graft = lookup_commit_graft(&commit->object.oid);
@ -796,7 +797,7 @@ static int fsck_commit_buffer(struct commit *commit, const char *buffer,
if (err) if (err)
return err; return err;
if (!get_commit_tree(commit)) { if (!get_commit_tree(commit)) {
err = report(options, &commit->object, FSCK_MSG_BAD_TREE, "could not load commit's tree %s", sha1_to_hex(tree_sha1)); err = report(options, &commit->object, FSCK_MSG_BAD_TREE, "could not load commit's tree %s", oid_to_hex(&tree_oid));
if (err) if (err)
return err; return err;
} }
@ -822,11 +823,12 @@ static int fsck_commit(struct commit *commit, const char *data,
static int fsck_tag_buffer(struct tag *tag, const char *data, static int fsck_tag_buffer(struct tag *tag, const char *data,
unsigned long size, struct fsck_options *options) unsigned long size, struct fsck_options *options)
{ {
unsigned char sha1[20]; struct object_id oid;
int ret = 0; int ret = 0;
const char *buffer; const char *buffer;
char *to_free = NULL, *eol; char *to_free = NULL, *eol;
struct strbuf sb = STRBUF_INIT; struct strbuf sb = STRBUF_INIT;
const char *p;
if (data) if (data)
buffer = data; buffer = data;
@ -857,12 +859,12 @@ static int fsck_tag_buffer(struct tag *tag, const char *data,
ret = report(options, &tag->object, FSCK_MSG_MISSING_OBJECT, "invalid format - expected 'object' line"); ret = report(options, &tag->object, FSCK_MSG_MISSING_OBJECT, "invalid format - expected 'object' line");
goto done; goto done;
} }
if (get_sha1_hex(buffer, sha1) || buffer[40] != '\n') { if (parse_oid_hex(buffer, &oid, &p) || *p != '\n') {
ret = report(options, &tag->object, FSCK_MSG_BAD_OBJECT_SHA1, "invalid 'object' line format - bad sha1"); ret = report(options, &tag->object, FSCK_MSG_BAD_OBJECT_SHA1, "invalid 'object' line format - bad sha1");
if (ret) if (ret)
goto done; goto done;
} }
buffer += 41; buffer = p + 1;
if (!skip_prefix(buffer, "type ", &buffer)) { if (!skip_prefix(buffer, "type ", &buffer)) {
ret = report(options, &tag->object, FSCK_MSG_MISSING_TYPE_ENTRY, "invalid format - expected 'type' line"); ret = report(options, &tag->object, FSCK_MSG_MISSING_TYPE_ENTRY, "invalid format - expected 'type' line");

View File

@ -205,8 +205,15 @@ my $status_head = sprintf($status_fmt, __('staged'), __('unstaged'), __('path'))
} }
} }
sub get_empty_tree { {
return '4b825dc642cb6eb9a060e54bf8d69288fbee4904'; my $empty_tree;
sub get_empty_tree {
return $empty_tree if defined $empty_tree;
$empty_tree = run_cmd_pipe(qw(git hash-object -t tree /dev/null));
chomp $empty_tree;
return $empty_tree;
}
} }
sub get_diff_reference { sub get_diff_reference {

View File

@ -11,6 +11,8 @@
# The following functions will also be available in the commit filter: # The following functions will also be available in the commit filter:
functions=$(cat << \EOF functions=$(cat << \EOF
EMPTY_TREE=$(git hash-object -t tree /dev/null)
warn () { warn () {
echo "$*" >&2 echo "$*" >&2
} }
@ -46,7 +48,7 @@ git_commit_non_empty_tree()
{ {
if test $# = 3 && test "$1" = $(git rev-parse "$3^{tree}"); then if test $# = 3 && test "$1" = $(git rev-parse "$3^{tree}"); then
map "$3" map "$3"
elif test $# = 1 && test "$1" = 4b825dc642cb6eb9a060e54bf8d69288fbee4904; then elif test $# = 1 && test "$1" = $EMPTY_TREE; then
: :
else else
git commit-tree "$@" git commit-tree "$@"

View File

@ -120,7 +120,7 @@ case "${1:-.}${2:-.}${3:-.}" in
case "$1" in case "$1" in
'') '')
echo "Added $4 in both, but differently." echo "Added $4 in both, but differently."
orig=$(git unpack-file e69de29bb2d1d6434b8b29ae775ad8c2e48c5391) orig=$(git unpack-file $(git hash-object /dev/null))
;; ;;
*) *)
echo "Auto-merging $4" echo "Auto-merging $4"

View File

@ -81,6 +81,8 @@ rewritten_pending="$state_dir"/rewritten-pending
# and leaves CR at the end instead. # and leaves CR at the end instead.
cr=$(printf "\015") cr=$(printf "\015")
empty_tree=$(git hash-object -t tree /dev/null)
strategy_args=${strategy:+--strategy=$strategy} strategy_args=${strategy:+--strategy=$strategy}
test -n "$strategy_opts" && test -n "$strategy_opts" &&
eval ' eval '
@ -244,7 +246,7 @@ is_empty_commit() {
die "$(eval_gettext "\$sha1: not a commit that can be picked")" die "$(eval_gettext "\$sha1: not a commit that can be picked")"
} }
ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null) || ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null) ||
ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904 ptree=$empty_tree
test "$tree" = "$ptree" test "$tree" = "$ptree"
} }

13
http.c
View File

@ -2038,7 +2038,8 @@ int http_get_info_packs(const char *base_url, struct packed_git **packs_head)
int ret = 0, i = 0; int ret = 0, i = 0;
char *url, *data; char *url, *data;
struct strbuf buf = STRBUF_INIT; struct strbuf buf = STRBUF_INIT;
unsigned char sha1[20]; unsigned char hash[GIT_MAX_RAWSZ];
const unsigned hexsz = the_hash_algo->hexsz;
end_url_with_slash(&buf, base_url); end_url_with_slash(&buf, base_url);
strbuf_addstr(&buf, "objects/info/packs"); strbuf_addstr(&buf, "objects/info/packs");
@ -2054,13 +2055,13 @@ int http_get_info_packs(const char *base_url, struct packed_git **packs_head)
switch (data[i]) { switch (data[i]) {
case 'P': case 'P':
i++; i++;
if (i + 52 <= buf.len && if (i + hexsz + 12 <= buf.len &&
starts_with(data + i, " pack-") && starts_with(data + i, " pack-") &&
starts_with(data + i + 46, ".pack\n")) { starts_with(data + i + hexsz + 6, ".pack\n")) {
get_sha1_hex(data + i + 6, sha1); get_sha1_hex(data + i + 6, hash);
fetch_and_setup_pack_index(packs_head, sha1, fetch_and_setup_pack_index(packs_head, hash,
base_url); base_url);
i += 51; i += hexsz + 11;
break; break;
} }
default: default:

View File

@ -11,10 +11,7 @@
static const char *merge_argument(struct commit *commit) static const char *merge_argument(struct commit *commit)
{ {
if (commit) return oid_to_hex(commit ? &commit->object.oid : the_hash_algo->empty_tree);
return oid_to_hex(&commit->object.oid);
else
return EMPTY_TREE_SHA1_HEX;
} }
int index_has_changes(struct strbuf *sb) int index_has_changes(struct strbuf *sb)

View File

@ -84,6 +84,7 @@ static int check_packed_git_idx(const char *path, struct packed_git *p)
uint32_t version, nr, i, *index; uint32_t version, nr, i, *index;
int fd = git_open(path); int fd = git_open(path);
struct stat st; struct stat st;
const unsigned int hashsz = the_hash_algo->rawsz;
if (fd < 0) if (fd < 0)
return -1; return -1;
@ -92,7 +93,7 @@ static int check_packed_git_idx(const char *path, struct packed_git *p)
return -1; return -1;
} }
idx_size = xsize_t(st.st_size); idx_size = xsize_t(st.st_size);
if (idx_size < 4 * 256 + 20 + 20) { if (idx_size < 4 * 256 + hashsz + hashsz) {
close(fd); close(fd);
return error("index file %s is too small", path); return error("index file %s is too small", path);
} }
@ -129,11 +130,11 @@ static int check_packed_git_idx(const char *path, struct packed_git *p)
/* /*
* Total size: * Total size:
* - 256 index entries 4 bytes each * - 256 index entries 4 bytes each
* - 24-byte entries * nr (20-byte sha1 + 4-byte offset) * - 24-byte entries * nr (object ID + 4-byte offset)
* - 20-byte SHA1 of the packfile * - hash of the packfile
* - 20-byte SHA1 file checksum * - file checksum
*/ */
if (idx_size != 4*256 + nr * 24 + 20 + 20) { if (idx_size != 4*256 + nr * (hashsz + 4) + hashsz + hashsz) {
munmap(idx_map, idx_size); munmap(idx_map, idx_size);
return error("wrong index v1 file size in %s", path); return error("wrong index v1 file size in %s", path);
} }
@ -142,16 +143,16 @@ static int check_packed_git_idx(const char *path, struct packed_git *p)
* Minimum size: * Minimum size:
* - 8 bytes of header * - 8 bytes of header
* - 256 index entries 4 bytes each * - 256 index entries 4 bytes each
* - 20-byte sha1 entry * nr * - object ID entry * nr
* - 4-byte crc entry * nr * - 4-byte crc entry * nr
* - 4-byte offset entry * nr * - 4-byte offset entry * nr
* - 20-byte SHA1 of the packfile * - hash of the packfile
* - 20-byte SHA1 file checksum * - file checksum
* And after the 4-byte offset table might be a * And after the 4-byte offset table might be a
* variable sized table containing 8-byte entries * variable sized table containing 8-byte entries
* for offsets larger than 2^31. * for offsets larger than 2^31.
*/ */
unsigned long min_size = 8 + 4*256 + nr*(20 + 4 + 4) + 20 + 20; unsigned long min_size = 8 + 4*256 + nr*(hashsz + 4 + 4) + hashsz + hashsz;
unsigned long max_size = min_size; unsigned long max_size = min_size;
if (nr) if (nr)
max_size += (nr - 1)*8; max_size += (nr - 1)*8;
@ -444,10 +445,11 @@ static int open_packed_git_1(struct packed_git *p)
{ {
struct stat st; struct stat st;
struct pack_header hdr; struct pack_header hdr;
unsigned char sha1[20]; unsigned char hash[GIT_MAX_RAWSZ];
unsigned char *idx_sha1; unsigned char *idx_hash;
long fd_flag; long fd_flag;
ssize_t read_result; ssize_t read_result;
const unsigned hashsz = the_hash_algo->rawsz;
if (!p->index_data && open_pack_index(p)) if (!p->index_data && open_pack_index(p))
return error("packfile %s index unavailable", p->pack_name); return error("packfile %s index unavailable", p->pack_name);
@ -507,15 +509,15 @@ static int open_packed_git_1(struct packed_git *p)
" while index indicates %"PRIu32" objects", " while index indicates %"PRIu32" objects",
p->pack_name, ntohl(hdr.hdr_entries), p->pack_name, ntohl(hdr.hdr_entries),
p->num_objects); p->num_objects);
if (lseek(p->pack_fd, p->pack_size - sizeof(sha1), SEEK_SET) == -1) if (lseek(p->pack_fd, p->pack_size - hashsz, SEEK_SET) == -1)
return error("end of packfile %s is unavailable", p->pack_name); return error("end of packfile %s is unavailable", p->pack_name);
read_result = read_in_full(p->pack_fd, sha1, sizeof(sha1)); read_result = read_in_full(p->pack_fd, hash, hashsz);
if (read_result < 0) if (read_result < 0)
return error_errno("error reading from %s", p->pack_name); return error_errno("error reading from %s", p->pack_name);
if (read_result != sizeof(sha1)) if (read_result != hashsz)
return error("packfile %s signature is unavailable", p->pack_name); return error("packfile %s signature is unavailable", p->pack_name);
idx_sha1 = ((unsigned char *)p->index_data) + p->index_size - 40; idx_hash = ((unsigned char *)p->index_data) + p->index_size - hashsz * 2;
if (hashcmp(sha1, idx_sha1)) if (hashcmp(hash, idx_hash))
return error("packfile %s does not match index", p->pack_name); return error("packfile %s does not match index", p->pack_name);
return 0; return 0;
} }
@ -530,7 +532,7 @@ static int open_packed_git(struct packed_git *p)
static int in_window(struct pack_window *win, off_t offset) static int in_window(struct pack_window *win, off_t offset)
{ {
/* We must promise at least 20 bytes (one hash) after the /* We must promise at least one full hash after the
* offset is available from this window, otherwise the offset * offset is available from this window, otherwise the offset
* is not actually in this window and a different window (which * is not actually in this window and a different window (which
* has that one hash excess) must be used. This is to support * has that one hash excess) must be used. This is to support
@ -538,7 +540,7 @@ static int in_window(struct pack_window *win, off_t offset)
*/ */
off_t win_off = win->offset; off_t win_off = win->offset;
return win_off <= offset return win_off <= offset
&& (offset + 20) <= (win_off + win->len); && (offset + the_hash_algo->rawsz) <= (win_off + win->len);
} }
unsigned char *use_pack(struct packed_git *p, unsigned char *use_pack(struct packed_git *p,
@ -555,7 +557,7 @@ unsigned char *use_pack(struct packed_git *p,
*/ */
if (!p->pack_size && p->pack_fd == -1 && open_packed_git(p)) if (!p->pack_size && p->pack_fd == -1 && open_packed_git(p))
die("packfile %s cannot be accessed", p->pack_name); die("packfile %s cannot be accessed", p->pack_name);
if (offset > (p->pack_size - 20)) if (offset > (p->pack_size - the_hash_algo->rawsz))
die("offset beyond end of packfile (truncated pack?)"); die("offset beyond end of packfile (truncated pack?)");
if (offset < 0) if (offset < 0)
die(_("offset before end of packfile (broken .idx?)")); die(_("offset before end of packfile (broken .idx?)"));
@ -675,7 +677,8 @@ struct packed_git *add_packed_git(const char *path, size_t path_len, int local)
p->pack_size = st.st_size; p->pack_size = st.st_size;
p->pack_local = local; p->pack_local = local;
p->mtime = st.st_mtime; p->mtime = st.st_mtime;
if (path_len < 40 || get_sha1_hex(path + path_len - 40, p->sha1)) if (path_len < the_hash_algo->hexsz ||
get_sha1_hex(path + path_len - the_hash_algo->hexsz, p->sha1))
hashclr(p->sha1); hashclr(p->sha1);
return p; return p;
} }
@ -1028,7 +1031,8 @@ const struct packed_git *has_packed_and_bad(const unsigned char *sha1)
for (p = the_repository->objects->packed_git; p; p = p->next) for (p = the_repository->objects->packed_git; p; p = p->next)
for (i = 0; i < p->num_bad_objects; i++) for (i = 0; i < p->num_bad_objects; i++)
if (!hashcmp(sha1, p->bad_object_sha1 + 20 * i)) if (!hashcmp(sha1,
p->bad_object_sha1 + the_hash_algo->rawsz * i))
return p; return p;
return NULL; return NULL;
} }
@ -1066,7 +1070,7 @@ static off_t get_delta_base(struct packed_git *p,
} else if (type == OBJ_REF_DELTA) { } else if (type == OBJ_REF_DELTA) {
/* The base entry _must_ be in the same pack */ /* The base entry _must_ be in the same pack */
base_offset = find_pack_entry_one(base_info, p); base_offset = find_pack_entry_one(base_info, p);
*curpos += 20; *curpos += the_hash_algo->rawsz;
} else } else
die("I am totally screwed"); die("I am totally screwed");
return base_offset; return base_offset;
@ -1677,6 +1681,7 @@ int bsearch_pack(const struct object_id *oid, const struct packed_git *p, uint32
{ {
const unsigned char *index_fanout = p->index_data; const unsigned char *index_fanout = p->index_data;
const unsigned char *index_lookup; const unsigned char *index_lookup;
const unsigned int hashsz = the_hash_algo->rawsz;
int index_lookup_width; int index_lookup_width;
if (!index_fanout) if (!index_fanout)
@ -1684,10 +1689,10 @@ int bsearch_pack(const struct object_id *oid, const struct packed_git *p, uint32
index_lookup = index_fanout + 4 * 256; index_lookup = index_fanout + 4 * 256;
if (p->index_version == 1) { if (p->index_version == 1) {
index_lookup_width = 24; index_lookup_width = hashsz + 4;
index_lookup += 4; index_lookup += 4;
} else { } else {
index_lookup_width = 20; index_lookup_width = hashsz;
index_fanout += 8; index_fanout += 8;
index_lookup += 8; index_lookup += 8;
} }
@ -1700,6 +1705,7 @@ const unsigned char *nth_packed_object_sha1(struct packed_git *p,
uint32_t n) uint32_t n)
{ {
const unsigned char *index = p->index_data; const unsigned char *index = p->index_data;
const unsigned int hashsz = the_hash_algo->rawsz;
if (!index) { if (!index) {
if (open_pack_index(p)) if (open_pack_index(p))
return NULL; return NULL;
@ -1709,10 +1715,10 @@ const unsigned char *nth_packed_object_sha1(struct packed_git *p,
return NULL; return NULL;
index += 4 * 256; index += 4 * 256;
if (p->index_version == 1) { if (p->index_version == 1) {
return index + 24 * n + 4; return index + (hashsz + 4) * n + 4;
} else { } else {
index += 8; index += 8;
return index + 20 * n; return index + hashsz * n;
} }
} }
@ -1744,12 +1750,13 @@ void check_pack_index_ptr(const struct packed_git *p, const void *vptr)
off_t nth_packed_object_offset(const struct packed_git *p, uint32_t n) off_t nth_packed_object_offset(const struct packed_git *p, uint32_t n)
{ {
const unsigned char *index = p->index_data; const unsigned char *index = p->index_data;
const unsigned int hashsz = the_hash_algo->rawsz;
index += 4 * 256; index += 4 * 256;
if (p->index_version == 1) { if (p->index_version == 1) {
return ntohl(*((uint32_t *)(index + 24 * n))); return ntohl(*((uint32_t *)(index + (hashsz + 4) * n)));
} else { } else {
uint32_t off; uint32_t off;
index += 8 + p->num_objects * (20 + 4); index += 8 + p->num_objects * (hashsz + 4);
off = ntohl(*((uint32_t *)(index + 4 * n))); off = ntohl(*((uint32_t *)(index + 4 * n)));
if (!(off & 0x80000000)) if (!(off & 0x80000000))
return off; return off;
@ -1811,7 +1818,7 @@ struct packed_git *find_sha1_pack(const unsigned char *sha1,
} }
static int fill_pack_entry(const unsigned char *sha1, static int fill_pack_entry(const struct object_id *oid,
struct pack_entry *e, struct pack_entry *e,
struct packed_git *p) struct packed_git *p)
{ {
@ -1820,11 +1827,12 @@ static int fill_pack_entry(const unsigned char *sha1,
if (p->num_bad_objects) { if (p->num_bad_objects) {
unsigned i; unsigned i;
for (i = 0; i < p->num_bad_objects; i++) for (i = 0; i < p->num_bad_objects; i++)
if (!hashcmp(sha1, p->bad_object_sha1 + 20 * i)) if (!hashcmp(oid->hash,
p->bad_object_sha1 + the_hash_algo->rawsz * i))
return 0; return 0;
} }
offset = find_pack_entry_one(sha1, p); offset = find_pack_entry_one(oid->hash, p);
if (!offset) if (!offset)
return 0; return 0;
@ -1839,11 +1847,10 @@ static int fill_pack_entry(const unsigned char *sha1,
return 0; return 0;
e->offset = offset; e->offset = offset;
e->p = p; e->p = p;
hashcpy(e->sha1, sha1);
return 1; return 1;
} }
int find_pack_entry(struct repository *r, const unsigned char *sha1, struct pack_entry *e) int find_pack_entry(struct repository *r, const struct object_id *oid, struct pack_entry *e)
{ {
struct list_head *pos; struct list_head *pos;
@ -1853,7 +1860,7 @@ int find_pack_entry(struct repository *r, const unsigned char *sha1, struct pack
list_for_each(pos, &r->objects->packed_git_mru) { list_for_each(pos, &r->objects->packed_git_mru) {
struct packed_git *p = list_entry(pos, struct packed_git, mru); struct packed_git *p = list_entry(pos, struct packed_git, mru);
if (fill_pack_entry(sha1, e, p)) { if (fill_pack_entry(oid, e, p)) {
list_move(&p->mru, &r->objects->packed_git_mru); list_move(&p->mru, &r->objects->packed_git_mru);
return 1; return 1;
} }
@ -1861,10 +1868,10 @@ int find_pack_entry(struct repository *r, const unsigned char *sha1, struct pack
return 0; return 0;
} }
int has_sha1_pack(const unsigned char *sha1) int has_object_pack(const struct object_id *oid)
{ {
struct pack_entry e; struct pack_entry e;
return find_pack_entry(the_repository, sha1, &e); return find_pack_entry(the_repository, oid, &e);
} }
int has_pack_index(const unsigned char *sha1) int has_pack_index(const unsigned char *sha1)

View File

@ -137,9 +137,9 @@ extern const struct packed_git *has_packed_and_bad(const unsigned char *sha1);
* Iff a pack file in the given repository contains the object named by sha1, * Iff a pack file in the given repository contains the object named by sha1,
* return true and store its location to e. * return true and store its location to e.
*/ */
extern int find_pack_entry(struct repository *r, const unsigned char *sha1, struct pack_entry *e); extern int find_pack_entry(struct repository *r, const struct object_id *oid, struct pack_entry *e);
extern int has_sha1_pack(const unsigned char *sha1); extern int has_object_pack(const struct object_id *oid);
extern int has_pack_index(const unsigned char *sha1); extern int has_pack_index(const unsigned char *sha1);

View File

@ -1831,7 +1831,7 @@ int do_read_index(struct index_state *istate, const char *path, int must_exist)
if (verify_hdr(hdr, mmap_size) < 0) if (verify_hdr(hdr, mmap_size) < 0)
goto unmap; goto unmap;
hashcpy(istate->sha1, (const unsigned char *)hdr + mmap_size - the_hash_algo->rawsz); hashcpy(istate->oid.hash, (const unsigned char *)hdr + mmap_size - the_hash_algo->rawsz);
istate->version = ntohl(hdr->hdr_version); istate->version = ntohl(hdr->hdr_version);
istate->cache_nr = ntohl(hdr->hdr_entries); istate->cache_nr = ntohl(hdr->hdr_entries);
istate->cache_alloc = alloc_nr(istate->cache_nr); istate->cache_alloc = alloc_nr(istate->cache_nr);
@ -1903,7 +1903,7 @@ int read_index_from(struct index_state *istate, const char *path,
uint64_t start = getnanotime(); uint64_t start = getnanotime();
struct split_index *split_index; struct split_index *split_index;
int ret; int ret;
char *base_sha1_hex; char *base_oid_hex;
char *base_path; char *base_path;
/* istate->initialized covers both .git/index and .git/sharedindex.xxx */ /* istate->initialized covers both .git/index and .git/sharedindex.xxx */
@ -1914,7 +1914,7 @@ int read_index_from(struct index_state *istate, const char *path,
trace_performance_since(start, "read cache %s", path); trace_performance_since(start, "read cache %s", path);
split_index = istate->split_index; split_index = istate->split_index;
if (!split_index || is_null_sha1(split_index->base_sha1)) { if (!split_index || is_null_oid(&split_index->base_oid)) {
post_read_index_from(istate); post_read_index_from(istate);
return ret; return ret;
} }
@ -1924,13 +1924,13 @@ int read_index_from(struct index_state *istate, const char *path,
else else
split_index->base = xcalloc(1, sizeof(*split_index->base)); split_index->base = xcalloc(1, sizeof(*split_index->base));
base_sha1_hex = sha1_to_hex(split_index->base_sha1); base_oid_hex = oid_to_hex(&split_index->base_oid);
base_path = xstrfmt("%s/sharedindex.%s", gitdir, base_sha1_hex); base_path = xstrfmt("%s/sharedindex.%s", gitdir, base_oid_hex);
ret = do_read_index(split_index->base, base_path, 1); ret = do_read_index(split_index->base, base_path, 1);
if (hashcmp(split_index->base_sha1, split_index->base->sha1)) if (oidcmp(&split_index->base_oid, &split_index->base->oid))
die("broken index, expect %s in %s, got %s", die("broken index, expect %s in %s, got %s",
base_sha1_hex, base_path, base_oid_hex, base_path,
sha1_to_hex(split_index->base->sha1)); oid_to_hex(&split_index->base->oid));
freshen_shared_index(base_path, 0); freshen_shared_index(base_path, 0);
merge_base_index(istate); merge_base_index(istate);
@ -2219,7 +2219,7 @@ static int verify_index_from(const struct index_state *istate, const char *path)
if (n != the_hash_algo->rawsz) if (n != the_hash_algo->rawsz)
goto out; goto out;
if (hashcmp(istate->sha1, hash)) if (hashcmp(istate->oid.hash, hash))
goto out; goto out;
close(fd); close(fd);
@ -2398,7 +2398,7 @@ static int do_write_index(struct index_state *istate, struct tempfile *tempfile,
return -1; return -1;
} }
if (ce_flush(&c, newfd, istate->sha1)) if (ce_flush(&c, newfd, istate->oid.hash))
return -1; return -1;
if (close_tempfile_gently(tempfile)) { if (close_tempfile_gently(tempfile)) {
error(_("could not close '%s'"), tempfile->filename.buf); error(_("could not close '%s'"), tempfile->filename.buf);
@ -2522,10 +2522,10 @@ static int write_shared_index(struct index_state *istate,
return ret; return ret;
} }
ret = rename_tempfile(temp, ret = rename_tempfile(temp,
git_path("sharedindex.%s", sha1_to_hex(si->base->sha1))); git_path("sharedindex.%s", oid_to_hex(&si->base->oid)));
if (!ret) { if (!ret) {
hashcpy(si->base_sha1, si->base->sha1); oidcpy(&si->base_oid, &si->base->oid);
clean_shared_index_files(sha1_to_hex(si->base->sha1)); clean_shared_index_files(oid_to_hex(&si->base->oid));
} }
return ret; return ret;
@ -2579,13 +2579,13 @@ int write_locked_index(struct index_state *istate, struct lock_file *lock,
if (!si || alternate_index_output || if (!si || alternate_index_output ||
(istate->cache_changed & ~EXTMASK)) { (istate->cache_changed & ~EXTMASK)) {
if (si) if (si)
hashclr(si->base_sha1); oidclr(&si->base_oid);
ret = do_write_locked_index(istate, lock, flags); ret = do_write_locked_index(istate, lock, flags);
goto out; goto out;
} }
if (git_env_bool("GIT_TEST_SPLIT_INDEX", 0)) { if (git_env_bool("GIT_TEST_SPLIT_INDEX", 0)) {
int v = si->base_sha1[0]; int v = si->base_oid.hash[0];
if ((v & 15) < 6) if ((v & 15) < 6)
istate->cache_changed |= SPLIT_INDEX_ORDERED; istate->cache_changed |= SPLIT_INDEX_ORDERED;
} }
@ -2600,7 +2600,7 @@ int write_locked_index(struct index_state *istate, struct lock_file *lock,
temp = mks_tempfile(git_path("sharedindex_XXXXXX")); temp = mks_tempfile(git_path("sharedindex_XXXXXX"));
if (!temp) { if (!temp) {
hashclr(si->base_sha1); oidclr(&si->base_oid);
ret = do_write_locked_index(istate, lock, flags); ret = do_write_locked_index(istate, lock, flags);
goto out; goto out;
} }
@ -2620,7 +2620,7 @@ int write_locked_index(struct index_state *istate, struct lock_file *lock,
/* Freshen the shared index only if the split-index was written */ /* Freshen the shared index only if the split-index was written */
if (!ret && !new_shared_index) { if (!ret && !new_shared_index) {
const char *shared_index = git_path("sharedindex.%s", const char *shared_index = git_path("sharedindex.%s",
sha1_to_hex(si->base_sha1)); oid_to_hex(&si->base_oid));
freshen_shared_index(shared_index, 1); freshen_shared_index(shared_index, 1);
} }

View File

@ -90,7 +90,7 @@ struct string_list *resolve_undo_read(const char *data, unsigned long size)
continue; continue;
if (size < rawsz) if (size < rawsz)
goto error; goto error;
memcpy(ui->oid[i].hash, (const unsigned char *)data, rawsz); oidread(&ui->oid[i], (const unsigned char *)data);
size -= rawsz; size -= rawsz;
data += rawsz; data += rawsz;
} }

View File

@ -1762,6 +1762,7 @@ static int handle_revision_opt(struct rev_info *revs, int argc, const char **arg
const char *arg = argv[0]; const char *arg = argv[0];
const char *optarg; const char *optarg;
int argcount; int argcount;
const unsigned hexsz = the_hash_algo->hexsz;
/* pseudo revision arguments */ /* pseudo revision arguments */
if (!strcmp(arg, "--all") || !strcmp(arg, "--branches") || if (!strcmp(arg, "--all") || !strcmp(arg, "--branches") ||
@ -2049,8 +2050,8 @@ static int handle_revision_opt(struct rev_info *revs, int argc, const char **arg
revs->abbrev = strtoul(optarg, NULL, 10); revs->abbrev = strtoul(optarg, NULL, 10);
if (revs->abbrev < MINIMUM_ABBREV) if (revs->abbrev < MINIMUM_ABBREV)
revs->abbrev = MINIMUM_ABBREV; revs->abbrev = MINIMUM_ABBREV;
else if (revs->abbrev > 40) else if (revs->abbrev > hexsz)
revs->abbrev = 40; revs->abbrev = hexsz;
} else if (!strcmp(arg, "--abbrev-commit")) { } else if (!strcmp(arg, "--abbrev-commit")) {
revs->abbrev_commit = 1; revs->abbrev_commit = 1;
revs->abbrev_commit_given = 1; revs->abbrev_commit_given = 1;
@ -3097,7 +3098,7 @@ enum commit_action get_commit_action(struct rev_info *revs, struct commit *commi
{ {
if (commit->object.flags & SHOWN) if (commit->object.flags & SHOWN)
return commit_ignore; return commit_ignore;
if (revs->unpacked && has_sha1_pack(commit->object.oid.hash)) if (revs->unpacked && has_object_pack(&commit->object.oid))
return commit_ignore; return commit_ignore;
if (commit->object.flags & UNINTERESTING) if (commit->object.flags & UNINTERESTING)
return commit_ignore; return commit_ignore;

View File

@ -1247,7 +1247,7 @@ static int try_to_commit(struct strbuf *msg, const char *author,
if (!(flags & ALLOW_EMPTY) && !oidcmp(current_head ? if (!(flags & ALLOW_EMPTY) && !oidcmp(current_head ?
get_commit_tree_oid(current_head) : get_commit_tree_oid(current_head) :
&empty_tree_oid, &tree)) { the_hash_algo->empty_tree, &tree)) {
res = 1; /* run 'git commit' to display error message */ res = 1; /* run 'git commit' to display error message */
goto out; goto out;
} }
@ -1639,7 +1639,7 @@ static int do_pick_commit(enum todo_command command, struct commit *commit,
unborn = 1; unborn = 1;
} else if (unborn) } else if (unborn)
oidcpy(&head, the_hash_algo->empty_tree); oidcpy(&head, the_hash_algo->empty_tree);
if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD", if (index_differs_from(unborn ? empty_tree_oid_hex() : "HEAD",
NULL, 0)) NULL, 0))
return error_dirty_index(opts); return error_dirty_index(opts);
} }

View File

@ -92,8 +92,6 @@ static struct pack_info {
int old_num; int old_num;
int new_num; int new_num;
int nr_alloc; int nr_alloc;
int nr_heads;
unsigned char (*head)[20];
} **info; } **info;
static int num_pack; static int num_pack;
static const char *objdir; static const char *objdir;
@ -225,12 +223,9 @@ static void init_pack_info(const char *infofile, int force)
else else
stale = 1; stale = 1;
for (i = 0; i < num_pack; i++) { for (i = 0; i < num_pack; i++)
if (stale) { if (stale)
info[i]->old_num = -1; info[i]->old_num = -1;
info[i]->nr_heads = 0;
}
}
/* renumber them */ /* renumber them */
QSORT(info, num_pack, compare_info); QSORT(info, num_pack, compare_info);

View File

@ -36,12 +36,21 @@
/* The maximum size for an object header. */ /* The maximum size for an object header. */
#define MAX_HEADER_LEN 32 #define MAX_HEADER_LEN 32
#define EMPTY_TREE_SHA1_BIN_LITERAL \
"\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60" \
"\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04"
#define EMPTY_BLOB_SHA1_BIN_LITERAL \
"\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b" \
"\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91"
const unsigned char null_sha1[GIT_MAX_RAWSZ]; const unsigned char null_sha1[GIT_MAX_RAWSZ];
const struct object_id null_oid; const struct object_id null_oid;
const struct object_id empty_tree_oid = { static const struct object_id empty_tree_oid = {
EMPTY_TREE_SHA1_BIN_LITERAL EMPTY_TREE_SHA1_BIN_LITERAL
}; };
const struct object_id empty_blob_oid = { static const struct object_id empty_blob_oid = {
EMPTY_BLOB_SHA1_BIN_LITERAL EMPTY_BLOB_SHA1_BIN_LITERAL
}; };
@ -101,6 +110,18 @@ const struct git_hash_algo hash_algos[GIT_HASH_NALGOS] = {
}, },
}; };
const char *empty_tree_oid_hex(void)
{
static char buf[GIT_MAX_HEXSZ + 1];
return oid_to_hex_r(buf, the_hash_algo->empty_tree);
}
const char *empty_blob_oid_hex(void)
{
static char buf[GIT_MAX_HEXSZ + 1];
return oid_to_hex_r(buf, the_hash_algo->empty_blob);
}
/* /*
* This is meant to hold a *small* number of objects that you would * This is meant to hold a *small* number of objects that you would
* want read_sha1_file() to be able to return, but yet you do not want * want read_sha1_file() to be able to return, but yet you do not want
@ -108,7 +129,7 @@ const struct git_hash_algo hash_algos[GIT_HASH_NALGOS] = {
* application). * application).
*/ */
static struct cached_object { static struct cached_object {
unsigned char sha1[20]; struct object_id oid;
enum object_type type; enum object_type type;
void *buf; void *buf;
unsigned long size; unsigned long size;
@ -116,22 +137,22 @@ static struct cached_object {
static int cached_object_nr, cached_object_alloc; static int cached_object_nr, cached_object_alloc;
static struct cached_object empty_tree = { static struct cached_object empty_tree = {
EMPTY_TREE_SHA1_BIN_LITERAL, { EMPTY_TREE_SHA1_BIN_LITERAL },
OBJ_TREE, OBJ_TREE,
"", "",
0 0
}; };
static struct cached_object *find_cached_object(const unsigned char *sha1) static struct cached_object *find_cached_object(const struct object_id *oid)
{ {
int i; int i;
struct cached_object *co = cached_objects; struct cached_object *co = cached_objects;
for (i = 0; i < cached_object_nr; i++, co++) { for (i = 0; i < cached_object_nr; i++, co++) {
if (!hashcmp(co->sha1, sha1)) if (!oidcmp(&co->oid, oid))
return co; return co;
} }
if (!hashcmp(sha1, empty_tree.sha1)) if (!oidcmp(oid, the_hash_algo->empty_tree))
return &empty_tree; return &empty_tree;
return NULL; return NULL;
} }
@ -710,42 +731,42 @@ int check_and_freshen_file(const char *fn, int freshen)
return 1; return 1;
} }
static int check_and_freshen_local(const unsigned char *sha1, int freshen) static int check_and_freshen_local(const struct object_id *oid, int freshen)
{ {
static struct strbuf buf = STRBUF_INIT; static struct strbuf buf = STRBUF_INIT;
strbuf_reset(&buf); strbuf_reset(&buf);
sha1_file_name(the_repository, &buf, sha1); sha1_file_name(the_repository, &buf, oid->hash);
return check_and_freshen_file(buf.buf, freshen); return check_and_freshen_file(buf.buf, freshen);
} }
static int check_and_freshen_nonlocal(const unsigned char *sha1, int freshen) static int check_and_freshen_nonlocal(const struct object_id *oid, int freshen)
{ {
struct alternate_object_database *alt; struct alternate_object_database *alt;
prepare_alt_odb(the_repository); prepare_alt_odb(the_repository);
for (alt = the_repository->objects->alt_odb_list; alt; alt = alt->next) { for (alt = the_repository->objects->alt_odb_list; alt; alt = alt->next) {
const char *path = alt_sha1_path(alt, sha1); const char *path = alt_sha1_path(alt, oid->hash);
if (check_and_freshen_file(path, freshen)) if (check_and_freshen_file(path, freshen))
return 1; return 1;
} }
return 0; return 0;
} }
static int check_and_freshen(const unsigned char *sha1, int freshen) static int check_and_freshen(const struct object_id *oid, int freshen)
{ {
return check_and_freshen_local(sha1, freshen) || return check_and_freshen_local(oid, freshen) ||
check_and_freshen_nonlocal(sha1, freshen); check_and_freshen_nonlocal(oid, freshen);
} }
int has_loose_object_nonlocal(const unsigned char *sha1) int has_loose_object_nonlocal(const struct object_id *oid)
{ {
return check_and_freshen_nonlocal(sha1, 0); return check_and_freshen_nonlocal(oid, 0);
} }
static int has_loose_object(const unsigned char *sha1) static int has_loose_object(const struct object_id *oid)
{ {
return check_and_freshen(sha1, 0); return check_and_freshen(oid, 0);
} }
static void mmap_limit_check(size_t length) static void mmap_limit_check(size_t length)
@ -1250,7 +1271,7 @@ int oid_object_info_extended(struct repository *r, const struct object_id *oid,
oi = &blank_oi; oi = &blank_oi;
if (!(flags & OBJECT_INFO_SKIP_CACHED)) { if (!(flags & OBJECT_INFO_SKIP_CACHED)) {
struct cached_object *co = find_cached_object(real->hash); struct cached_object *co = find_cached_object(real);
if (co) { if (co) {
if (oi->typep) if (oi->typep)
*(oi->typep) = co->type; *(oi->typep) = co->type;
@ -1270,7 +1291,7 @@ int oid_object_info_extended(struct repository *r, const struct object_id *oid,
} }
while (1) { while (1) {
if (find_pack_entry(r, real->hash, &e)) if (find_pack_entry(r, real, &e))
break; break;
if (flags & OBJECT_INFO_IGNORE_LOOSE) if (flags & OBJECT_INFO_IGNORE_LOOSE)
@ -1283,7 +1304,7 @@ int oid_object_info_extended(struct repository *r, const struct object_id *oid,
/* Not a loose object; someone else may have just packed it. */ /* Not a loose object; someone else may have just packed it. */
if (!(flags & OBJECT_INFO_QUICK)) { if (!(flags & OBJECT_INFO_QUICK)) {
reprepare_packed_git(r); reprepare_packed_git(r);
if (find_pack_entry(r, real->hash, &e)) if (find_pack_entry(r, real, &e))
break; break;
} }
@ -1363,7 +1384,7 @@ int pretend_object_file(void *buf, unsigned long len, enum object_type type,
struct cached_object *co; struct cached_object *co;
hash_object_file(buf, len, type_name(type), oid); hash_object_file(buf, len, type_name(type), oid);
if (has_sha1_file(oid->hash) || find_cached_object(oid->hash)) if (has_sha1_file(oid->hash) || find_cached_object(oid))
return 0; return 0;
ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc); ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc);
co = &cached_objects[cached_object_nr++]; co = &cached_objects[cached_object_nr++];
@ -1371,7 +1392,7 @@ int pretend_object_file(void *buf, unsigned long len, enum object_type type,
co->type = type; co->type = type;
co->buf = xmalloc(len); co->buf = xmalloc(len);
memcpy(co->buf, buf, len); memcpy(co->buf, buf, len);
hashcpy(co->sha1, oid->hash); oidcpy(&co->oid, oid);
return 0; return 0;
} }
@ -1667,15 +1688,15 @@ static int write_loose_object(const struct object_id *oid, char *hdr,
return finalize_object_file(tmp_file.buf, filename.buf); return finalize_object_file(tmp_file.buf, filename.buf);
} }
static int freshen_loose_object(const unsigned char *sha1) static int freshen_loose_object(const struct object_id *oid)
{ {
return check_and_freshen(sha1, 1); return check_and_freshen(oid, 1);
} }
static int freshen_packed_object(const unsigned char *sha1) static int freshen_packed_object(const struct object_id *oid)
{ {
struct pack_entry e; struct pack_entry e;
if (!find_pack_entry(the_repository, sha1, &e)) if (!find_pack_entry(the_repository, oid, &e))
return 0; return 0;
if (e.p->freshened) if (e.p->freshened)
return 1; return 1;
@ -1695,7 +1716,7 @@ int write_object_file(const void *buf, unsigned long len, const char *type,
* it out into .git/objects/??/?{38} file. * it out into .git/objects/??/?{38} file.
*/ */
write_object_file_prepare(buf, len, type, oid, hdr, &hdrlen); write_object_file_prepare(buf, len, type, oid, hdr, &hdrlen);
if (freshen_packed_object(oid->hash) || freshen_loose_object(oid->hash)) if (freshen_packed_object(oid) || freshen_loose_object(oid))
return 0; return 0;
return write_loose_object(oid, hdr, hdrlen, buf, len, 0); return write_loose_object(oid, hdr, hdrlen, buf, len, 0);
} }
@ -1714,7 +1735,7 @@ int hash_object_file_literally(const void *buf, unsigned long len,
if (!(flags & HASH_WRITE_OBJECT)) if (!(flags & HASH_WRITE_OBJECT))
goto cleanup; goto cleanup;
if (freshen_packed_object(oid->hash) || freshen_loose_object(oid->hash)) if (freshen_packed_object(oid) || freshen_loose_object(oid))
goto cleanup; goto cleanup;
status = write_loose_object(oid, header, hdrlen, buf, len, 0); status = write_loose_object(oid, header, hdrlen, buf, len, 0);
@ -1732,7 +1753,7 @@ int force_object_loose(const struct object_id *oid, time_t mtime)
int hdrlen; int hdrlen;
int ret; int ret;
if (has_loose_object(oid->hash)) if (has_loose_object(oid))
return 0; return 0;
buf = read_object(oid->hash, &type, &len); buf = read_object(oid->hash, &type, &len);
if (!buf) if (!buf)

View File

@ -1685,8 +1685,8 @@ static int get_oid_with_context_1(const char *name,
if (new_filename) if (new_filename)
filename = new_filename; filename = new_filename;
if (flags & GET_OID_FOLLOW_SYMLINKS) { if (flags & GET_OID_FOLLOW_SYMLINKS) {
ret = get_tree_entry_follow_symlinks(tree_oid.hash, ret = get_tree_entry_follow_symlinks(&tree_oid,
filename, oid->hash, &oc->symlink_path, filename, oid, &oc->symlink_path,
&oc->mode); &oc->mode);
} else { } else {
ret = get_tree_entry(&tree_oid, filename, oid, ret = get_tree_entry(&tree_oid, filename, oid,
@ -1698,7 +1698,6 @@ static int get_oid_with_context_1(const char *name,
name, len); name, len);
} }
} }
hashcpy(oc->tree, tree_oid.hash);
if (flags & GET_OID_RECORD_PATH) if (flags & GET_OID_RECORD_PATH)
oc->path = xstrdup(filename); oc->path = xstrdup(filename);

View File

@ -18,12 +18,12 @@ int read_link_extension(struct index_state *istate,
struct split_index *si; struct split_index *si;
int ret; int ret;
if (sz < 20) if (sz < the_hash_algo->rawsz)
return error("corrupt link extension (too short)"); return error("corrupt link extension (too short)");
si = init_split_index(istate); si = init_split_index(istate);
hashcpy(si->base_sha1, data); hashcpy(si->base_oid.hash, data);
data += 20; data += the_hash_algo->rawsz;
sz -= 20; sz -= the_hash_algo->rawsz;
if (!sz) if (!sz)
return 0; return 0;
si->delete_bitmap = ewah_new(); si->delete_bitmap = ewah_new();
@ -45,7 +45,7 @@ int write_link_extension(struct strbuf *sb,
struct index_state *istate) struct index_state *istate)
{ {
struct split_index *si = istate->split_index; struct split_index *si = istate->split_index;
strbuf_add(sb, si->base_sha1, 20); strbuf_add(sb, si->base_oid.hash, the_hash_algo->rawsz);
if (!si->delete_bitmap && !si->replace_bitmap) if (!si->delete_bitmap && !si->replace_bitmap)
return 0; return 0;
ewah_serialize_strbuf(si->delete_bitmap, sb); ewah_serialize_strbuf(si->delete_bitmap, sb);

View File

@ -1,12 +1,14 @@
#ifndef SPLIT_INDEX_H #ifndef SPLIT_INDEX_H
#define SPLIT_INDEX_H #define SPLIT_INDEX_H
#include "cache.h"
struct index_state; struct index_state;
struct strbuf; struct strbuf;
struct ewah_bitmap; struct ewah_bitmap;
struct split_index { struct split_index {
unsigned char base_sha1[20]; struct object_id base_oid;
struct index_state *base; struct index_state *base;
struct ewah_bitmap *delete_bitmap; struct ewah_bitmap *delete_bitmap;
struct ewah_bitmap *replace_bitmap; struct ewah_bitmap *replace_bitmap;

View File

@ -44,7 +44,7 @@ static int config_path_cmp(const void *unused_cmp_data,
const struct submodule_entry *b = entry_or_key; const struct submodule_entry *b = entry_or_key;
return strcmp(a->config->path, b->config->path) || return strcmp(a->config->path, b->config->path) ||
hashcmp(a->config->gitmodules_sha1, b->config->gitmodules_sha1); oidcmp(&a->config->gitmodules_oid, &b->config->gitmodules_oid);
} }
static int config_name_cmp(const void *unused_cmp_data, static int config_name_cmp(const void *unused_cmp_data,
@ -56,7 +56,7 @@ static int config_name_cmp(const void *unused_cmp_data,
const struct submodule_entry *b = entry_or_key; const struct submodule_entry *b = entry_or_key;
return strcmp(a->config->name, b->config->name) || return strcmp(a->config->name, b->config->name) ||
hashcmp(a->config->gitmodules_sha1, b->config->gitmodules_sha1); oidcmp(&a->config->gitmodules_oid, &b->config->gitmodules_oid);
} }
static struct submodule_cache *submodule_cache_alloc(void) static struct submodule_cache *submodule_cache_alloc(void)
@ -109,16 +109,16 @@ void submodule_cache_free(struct submodule_cache *cache)
free(cache); free(cache);
} }
static unsigned int hash_sha1_string(const unsigned char *sha1, static unsigned int hash_oid_string(const struct object_id *oid,
const char *string) const char *string)
{ {
return memhash(sha1, 20) + strhash(string); return memhash(oid->hash, the_hash_algo->rawsz) + strhash(string);
} }
static void cache_put_path(struct submodule_cache *cache, static void cache_put_path(struct submodule_cache *cache,
struct submodule *submodule) struct submodule *submodule)
{ {
unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1, unsigned int hash = hash_oid_string(&submodule->gitmodules_oid,
submodule->path); submodule->path);
struct submodule_entry *e = xmalloc(sizeof(*e)); struct submodule_entry *e = xmalloc(sizeof(*e));
hashmap_entry_init(e, hash); hashmap_entry_init(e, hash);
@ -129,7 +129,7 @@ static void cache_put_path(struct submodule_cache *cache,
static void cache_remove_path(struct submodule_cache *cache, static void cache_remove_path(struct submodule_cache *cache,
struct submodule *submodule) struct submodule *submodule)
{ {
unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1, unsigned int hash = hash_oid_string(&submodule->gitmodules_oid,
submodule->path); submodule->path);
struct submodule_entry e; struct submodule_entry e;
struct submodule_entry *removed; struct submodule_entry *removed;
@ -142,7 +142,7 @@ static void cache_remove_path(struct submodule_cache *cache,
static void cache_add(struct submodule_cache *cache, static void cache_add(struct submodule_cache *cache,
struct submodule *submodule) struct submodule *submodule)
{ {
unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1, unsigned int hash = hash_oid_string(&submodule->gitmodules_oid,
submodule->name); submodule->name);
struct submodule_entry *e = xmalloc(sizeof(*e)); struct submodule_entry *e = xmalloc(sizeof(*e));
hashmap_entry_init(e, hash); hashmap_entry_init(e, hash);
@ -151,14 +151,14 @@ static void cache_add(struct submodule_cache *cache,
} }
static const struct submodule *cache_lookup_path(struct submodule_cache *cache, static const struct submodule *cache_lookup_path(struct submodule_cache *cache,
const unsigned char *gitmodules_sha1, const char *path) const struct object_id *gitmodules_oid, const char *path)
{ {
struct submodule_entry *entry; struct submodule_entry *entry;
unsigned int hash = hash_sha1_string(gitmodules_sha1, path); unsigned int hash = hash_oid_string(gitmodules_oid, path);
struct submodule_entry key; struct submodule_entry key;
struct submodule key_config; struct submodule key_config;
hashcpy(key_config.gitmodules_sha1, gitmodules_sha1); oidcpy(&key_config.gitmodules_oid, gitmodules_oid);
key_config.path = path; key_config.path = path;
hashmap_entry_init(&key, hash); hashmap_entry_init(&key, hash);
@ -171,14 +171,14 @@ static const struct submodule *cache_lookup_path(struct submodule_cache *cache,
} }
static struct submodule *cache_lookup_name(struct submodule_cache *cache, static struct submodule *cache_lookup_name(struct submodule_cache *cache,
const unsigned char *gitmodules_sha1, const char *name) const struct object_id *gitmodules_oid, const char *name)
{ {
struct submodule_entry *entry; struct submodule_entry *entry;
unsigned int hash = hash_sha1_string(gitmodules_sha1, name); unsigned int hash = hash_oid_string(gitmodules_oid, name);
struct submodule_entry key; struct submodule_entry key;
struct submodule key_config; struct submodule key_config;
hashcpy(key_config.gitmodules_sha1, gitmodules_sha1); oidcpy(&key_config.gitmodules_oid, gitmodules_oid);
key_config.name = name; key_config.name = name;
hashmap_entry_init(&key, hash); hashmap_entry_init(&key, hash);
@ -238,12 +238,12 @@ static int name_and_item_from_var(const char *var, struct strbuf *name,
} }
static struct submodule *lookup_or_create_by_name(struct submodule_cache *cache, static struct submodule *lookup_or_create_by_name(struct submodule_cache *cache,
const unsigned char *gitmodules_sha1, const char *name) const struct object_id *gitmodules_oid, const char *name)
{ {
struct submodule *submodule; struct submodule *submodule;
struct strbuf name_buf = STRBUF_INIT; struct strbuf name_buf = STRBUF_INIT;
submodule = cache_lookup_name(cache, gitmodules_sha1, name); submodule = cache_lookup_name(cache, gitmodules_oid, name);
if (submodule) if (submodule)
return submodule; return submodule;
@ -261,7 +261,7 @@ static struct submodule *lookup_or_create_by_name(struct submodule_cache *cache,
submodule->branch = NULL; submodule->branch = NULL;
submodule->recommend_shallow = -1; submodule->recommend_shallow = -1;
hashcpy(submodule->gitmodules_sha1, gitmodules_sha1); oidcpy(&submodule->gitmodules_oid, gitmodules_oid);
cache_add(cache, submodule); cache_add(cache, submodule);
@ -372,12 +372,12 @@ int parse_push_recurse_submodules_arg(const char *opt, const char *arg)
return parse_push_recurse(opt, arg, 1); return parse_push_recurse(opt, arg, 1);
} }
static void warn_multiple_config(const unsigned char *treeish_name, static void warn_multiple_config(const struct object_id *treeish_name,
const char *name, const char *option) const char *name, const char *option)
{ {
const char *commit_string = "WORKTREE"; const char *commit_string = "WORKTREE";
if (treeish_name) if (treeish_name)
commit_string = sha1_to_hex(treeish_name); commit_string = oid_to_hex(treeish_name);
warning("%s:.gitmodules, multiple configurations found for " warning("%s:.gitmodules, multiple configurations found for "
"'submodule.%s.%s'. Skipping second one!", "'submodule.%s.%s'. Skipping second one!",
commit_string, name, option); commit_string, name, option);
@ -385,8 +385,8 @@ static void warn_multiple_config(const unsigned char *treeish_name,
struct parse_config_parameter { struct parse_config_parameter {
struct submodule_cache *cache; struct submodule_cache *cache;
const unsigned char *treeish_name; const struct object_id *treeish_name;
const unsigned char *gitmodules_sha1; const struct object_id *gitmodules_oid;
int overwrite; int overwrite;
}; };
@ -402,7 +402,7 @@ static int parse_config(const char *var, const char *value, void *data)
return 0; return 0;
submodule = lookup_or_create_by_name(me->cache, submodule = lookup_or_create_by_name(me->cache,
me->gitmodules_sha1, me->gitmodules_oid,
name.buf); name.buf);
if (!strcmp(item.buf, "path")) { if (!strcmp(item.buf, "path")) {
@ -420,7 +420,7 @@ static int parse_config(const char *var, const char *value, void *data)
} }
} else if (!strcmp(item.buf, "fetchrecursesubmodules")) { } else if (!strcmp(item.buf, "fetchrecursesubmodules")) {
/* when parsing worktree configurations we can die early */ /* when parsing worktree configurations we can die early */
int die_on_error = is_null_sha1(me->gitmodules_sha1); int die_on_error = is_null_oid(me->gitmodules_oid);
if (!me->overwrite && if (!me->overwrite &&
submodule->fetch_recurse != RECURSE_SUBMODULES_NONE) submodule->fetch_recurse != RECURSE_SUBMODULES_NONE)
warn_multiple_config(me->treeish_name, submodule->name, warn_multiple_config(me->treeish_name, submodule->name,
@ -542,10 +542,10 @@ static const struct submodule *config_from(struct submodule_cache *cache,
switch (lookup_type) { switch (lookup_type) {
case lookup_name: case lookup_name:
submodule = cache_lookup_name(cache, oid.hash, key); submodule = cache_lookup_name(cache, &oid, key);
break; break;
case lookup_path: case lookup_path:
submodule = cache_lookup_path(cache, oid.hash, key); submodule = cache_lookup_path(cache, &oid, key);
break; break;
} }
if (submodule) if (submodule)
@ -557,8 +557,8 @@ static const struct submodule *config_from(struct submodule_cache *cache,
/* fill the submodule config into the cache */ /* fill the submodule config into the cache */
parameter.cache = cache; parameter.cache = cache;
parameter.treeish_name = treeish_name->hash; parameter.treeish_name = treeish_name;
parameter.gitmodules_sha1 = oid.hash; parameter.gitmodules_oid = &oid;
parameter.overwrite = 0; parameter.overwrite = 0;
git_config_from_mem(parse_config, CONFIG_ORIGIN_SUBMODULE_BLOB, rev.buf, git_config_from_mem(parse_config, CONFIG_ORIGIN_SUBMODULE_BLOB, rev.buf,
config, config_size, &parameter); config, config_size, &parameter);
@ -567,9 +567,9 @@ static const struct submodule *config_from(struct submodule_cache *cache,
switch (lookup_type) { switch (lookup_type) {
case lookup_name: case lookup_name:
return cache_lookup_name(cache, oid.hash, key); return cache_lookup_name(cache, &oid, key);
case lookup_path: case lookup_path:
return cache_lookup_path(cache, oid.hash, key); return cache_lookup_path(cache, &oid, key);
default: default:
return NULL; return NULL;
} }
@ -598,7 +598,7 @@ static int gitmodules_cb(const char *var, const char *value, void *data)
parameter.cache = repo->submodule_cache; parameter.cache = repo->submodule_cache;
parameter.treeish_name = NULL; parameter.treeish_name = NULL;
parameter.gitmodules_sha1 = null_sha1; parameter.gitmodules_oid = &null_oid;
parameter.overwrite = 1; parameter.overwrite = 1;
return parse_config(var, value, &parameter); return parse_config(var, value, &parameter);

View File

@ -1,6 +1,7 @@
#ifndef SUBMODULE_CONFIG_CACHE_H #ifndef SUBMODULE_CONFIG_CACHE_H
#define SUBMODULE_CONFIG_CACHE_H #define SUBMODULE_CONFIG_CACHE_H
#include "cache.h"
#include "hashmap.h" #include "hashmap.h"
#include "submodule.h" #include "submodule.h"
#include "strbuf.h" #include "strbuf.h"
@ -17,13 +18,13 @@ struct submodule {
const char *ignore; const char *ignore;
const char *branch; const char *branch;
struct submodule_update_strategy update_strategy; struct submodule_update_strategy update_strategy;
/* the sha1 blob id of the responsible .gitmodules file */ /* the object id of the responsible .gitmodules file */
unsigned char gitmodules_sha1[20]; struct object_id gitmodules_oid;
int recommend_shallow; int recommend_shallow;
}; };
#define SUBMODULE_INIT { NULL, NULL, NULL, RECURSE_SUBMODULES_NONE, \ #define SUBMODULE_INIT { NULL, NULL, NULL, RECURSE_SUBMODULES_NONE, \
NULL, NULL, SUBMODULE_UPDATE_STRATEGY_INIT, {0}, -1 }; NULL, NULL, SUBMODULE_UPDATE_STRATEGY_INIT, { { 0 } }, -1 };
struct submodule_cache; struct submodule_cache;
struct repository; struct repository;

View File

@ -1569,7 +1569,7 @@ static void submodule_reset_index(const char *path)
get_super_prefix_or_empty(), path); get_super_prefix_or_empty(), path);
argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL); argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);
argv_array_push(&cp.args, EMPTY_TREE_SHA1_HEX); argv_array_push(&cp.args, empty_tree_oid_hex());
if (run_command(&cp)) if (run_command(&cp))
die("could not reset submodule index"); die("could not reset submodule index");
@ -1661,9 +1661,9 @@ int submodule_move_head(const char *path,
argv_array_push(&cp.args, "-m"); argv_array_push(&cp.args, "-m");
if (!(flags & SUBMODULE_MOVE_HEAD_FORCE)) if (!(flags & SUBMODULE_MOVE_HEAD_FORCE))
argv_array_push(&cp.args, old_head ? old_head : EMPTY_TREE_SHA1_HEX); argv_array_push(&cp.args, old_head ? old_head : empty_tree_oid_hex());
argv_array_push(&cp.args, new_head ? new_head : EMPTY_TREE_SHA1_HEX); argv_array_push(&cp.args, new_head ? new_head : empty_tree_oid_hex());
if (run_command(&cp)) { if (run_command(&cp)) {
ret = -1; ret = -1;

View File

@ -14,13 +14,13 @@ int cmd__dump_split_index(int ac, const char **av)
int i; int i;
do_read_index(&the_index, av[1], 1); do_read_index(&the_index, av[1], 1);
printf("own %s\n", sha1_to_hex(the_index.sha1)); printf("own %s\n", oid_to_hex(&the_index.oid));
si = the_index.split_index; si = the_index.split_index;
if (!si) { if (!si) {
printf("not a split index\n"); printf("not a split index\n");
return 0; return 0;
} }
printf("base %s\n", sha1_to_hex(si->base_sha1)); printf("base %s\n", oid_to_hex(&si->base_oid));
for (i = 0; i < the_index.cache_nr; i++) { for (i = 0; i < the_index.cache_nr; i++) {
struct cache_entry *ce = the_index.cache[i]; struct cache_entry *ce = the_index.cache[i];
printf("%06o %s %d\t%s\n", ce->ce_mode, printf("%06o %s %d\t%s\n", ce->ce_mode,

View File

@ -23,7 +23,7 @@ static void dump(struct untracked_cache_dir *ucd, struct strbuf *base)
len = base->len; len = base->len;
strbuf_addf(base, "%s/", ucd->name); strbuf_addf(base, "%s/", ucd->name);
printf("%s %s", base->buf, printf("%s %s", base->buf,
sha1_to_hex(ucd->exclude_sha1)); oid_to_hex(&ucd->exclude_oid));
if (ucd->recurse) if (ucd->recurse)
fputs(" recurse", stdout); fputs(" recurse", stdout);
if (ucd->check_only) if (ucd->check_only)

View File

@ -12,7 +12,7 @@ then
against=HEAD against=HEAD
else else
# Initial commit: diff against an empty tree object # Initial commit: diff against an empty tree object
against=4b825dc642cb6eb9a060e54bf8d69288fbee4904 against=$(git hash-object -t tree /dev/null)
fi fi
# If you want to allow non-ASCII filenames set this variable to true. # If you want to allow non-ASCII filenames set this variable to true.

View File

@ -105,7 +105,7 @@ static void entry_extract(struct tree_desc *t, struct name_entry *a)
static int update_tree_entry_internal(struct tree_desc *desc, struct strbuf *err) static int update_tree_entry_internal(struct tree_desc *desc, struct strbuf *err)
{ {
const void *buf = desc->buffer; const void *buf = desc->buffer;
const unsigned char *end = desc->entry.oid->hash + 20; const unsigned char *end = desc->entry.oid->hash + the_hash_algo->rawsz;
unsigned long size = desc->size; unsigned long size = desc->size;
unsigned long len = end - (const unsigned char *)buf; unsigned long len = end - (const unsigned char *)buf;
@ -488,7 +488,7 @@ int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info)
struct dir_state { struct dir_state {
void *tree; void *tree;
unsigned long size; unsigned long size;
unsigned char sha1[20]; struct object_id oid;
}; };
static int find_tree_entry(struct tree_desc *t, const char *name, struct object_id *result, unsigned *mode) static int find_tree_entry(struct tree_desc *t, const char *name, struct object_id *result, unsigned *mode)
@ -576,7 +576,7 @@ int get_tree_entry(const struct object_id *tree_oid, const char *name, struct ob
* See the code for enum follow_symlink_result for a description of * See the code for enum follow_symlink_result for a description of
* the return values. * the return values.
*/ */
enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_sha1, const char *name, unsigned char *result, struct strbuf *result_path, unsigned *mode) enum follow_symlinks_result get_tree_entry_follow_symlinks(struct object_id *tree_oid, const char *name, struct object_id *result, struct strbuf *result_path, unsigned *mode)
{ {
int retval = MISSING_OBJECT; int retval = MISSING_OBJECT;
struct dir_state *parents = NULL; struct dir_state *parents = NULL;
@ -589,7 +589,7 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
init_tree_desc(&t, NULL, 0UL); init_tree_desc(&t, NULL, 0UL);
strbuf_addstr(&namebuf, name); strbuf_addstr(&namebuf, name);
hashcpy(current_tree_oid.hash, tree_sha1); oidcpy(&current_tree_oid, tree_oid);
while (1) { while (1) {
int find_result; int find_result;
@ -609,11 +609,11 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
ALLOC_GROW(parents, parents_nr + 1, parents_alloc); ALLOC_GROW(parents, parents_nr + 1, parents_alloc);
parents[parents_nr].tree = tree; parents[parents_nr].tree = tree;
parents[parents_nr].size = size; parents[parents_nr].size = size;
hashcpy(parents[parents_nr].sha1, root.hash); oidcpy(&parents[parents_nr].oid, &root);
parents_nr++; parents_nr++;
if (namebuf.buf[0] == '\0') { if (namebuf.buf[0] == '\0') {
hashcpy(result, root.hash); oidcpy(result, &root);
retval = FOUND; retval = FOUND;
goto done; goto done;
} }
@ -663,7 +663,7 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
/* We could end up here via a symlink to dir/.. */ /* We could end up here via a symlink to dir/.. */
if (namebuf.buf[0] == '\0') { if (namebuf.buf[0] == '\0') {
hashcpy(result, parents[parents_nr - 1].sha1); oidcpy(result, &parents[parents_nr - 1].oid);
retval = FOUND; retval = FOUND;
goto done; goto done;
} }
@ -677,7 +677,7 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
if (S_ISDIR(*mode)) { if (S_ISDIR(*mode)) {
if (!remainder) { if (!remainder) {
hashcpy(result, current_tree_oid.hash); oidcpy(result, &current_tree_oid);
retval = FOUND; retval = FOUND;
goto done; goto done;
} }
@ -687,7 +687,7 @@ enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_s
1 + first_slash - namebuf.buf); 1 + first_slash - namebuf.buf);
} else if (S_ISREG(*mode)) { } else if (S_ISREG(*mode)) {
if (!remainder) { if (!remainder) {
hashcpy(result, current_tree_oid.hash); oidcpy(result, &current_tree_oid);
retval = FOUND; retval = FOUND;
} else { } else {
retval = NOT_DIR; retval = NOT_DIR;

View File

@ -64,7 +64,7 @@ enum follow_symlinks_result {
*/ */
}; };
enum follow_symlinks_result get_tree_entry_follow_symlinks(unsigned char *tree_sha1, const char *name, unsigned char *result, struct strbuf *result_path, unsigned *mode); enum follow_symlinks_result get_tree_entry_follow_symlinks(struct object_id *tree_oid, const char *name, struct object_id *result, struct strbuf *result_path, unsigned *mode);
struct traverse_info { struct traverse_info {
const char *traverse_path; const char *traverse_path;

View File

@ -1298,7 +1298,7 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
} else { } else {
o->result.split_index = init_split_index(&o->result); o->result.split_index = init_split_index(&o->result);
} }
hashcpy(o->result.sha1, o->src_index->sha1); oidcpy(&o->result.oid, &o->src_index->oid);
o->merge_size = len; o->merge_size = len;
mark_all_ce_unused(o->src_index); mark_all_ce_unused(o->src_index);

View File

@ -444,7 +444,7 @@ static int get_common_commits(void)
break; break;
default: default:
got_common = 1; got_common = 1;
memcpy(last_hex, oid_to_hex(&oid), 41); oid_to_hex_r(last_hex, &oid);
if (multi_ack == 2) if (multi_ack == 2)
packet_write_fmt(1, "ACK %s common\n", last_hex); packet_write_fmt(1, "ACK %s common\n", last_hex);
else if (multi_ack) else if (multi_ack)
@ -486,7 +486,7 @@ static int do_reachable_revlist(struct child_process *cmd,
"rev-list", "--stdin", NULL, "rev-list", "--stdin", NULL,
}; };
struct object *o; struct object *o;
char namebuf[42]; /* ^ + SHA-1 + LF */ char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
int i; int i;
cmd->argv = argv; cmd->argv = argv;
@ -555,15 +555,17 @@ static int get_reachable_list(struct object_array *src,
struct child_process cmd = CHILD_PROCESS_INIT; struct child_process cmd = CHILD_PROCESS_INIT;
int i; int i;
struct object *o; struct object *o;
char namebuf[42]; /* ^ + SHA-1 + LF */ char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
const unsigned hexsz = the_hash_algo->hexsz;
if (do_reachable_revlist(&cmd, src, reachable) < 0) if (do_reachable_revlist(&cmd, src, reachable) < 0)
return -1; return -1;
while ((i = read_in_full(cmd.out, namebuf, 41)) == 41) { while ((i = read_in_full(cmd.out, namebuf, hexsz + 1)) == hexsz + 1) {
struct object_id sha1; struct object_id sha1;
const char *p;
if (namebuf[40] != '\n' || get_oid_hex(namebuf, &sha1)) if (parse_oid_hex(namebuf, &sha1, &p) || *p != '\n')
break; break;
o = lookup_object(sha1.hash); o = lookup_object(sha1.hash);
@ -895,11 +897,9 @@ static void receive_needs(void)
} }
if (!skip_prefix(line, "want ", &arg) || if (!skip_prefix(line, "want ", &arg) ||
get_oid_hex(arg, &oid_buf)) parse_oid_hex(arg, &oid_buf, &features))
die("git upload-pack: protocol error, " die("git upload-pack: protocol error, "
"expected to get sha, not '%s'", line); "expected to get object ID, not '%s'", line);
features = arg + 40;
if (parse_feature_request(features, "deepen-relative")) if (parse_feature_request(features, "deepen-relative"))
deepen_relative = 1; deepen_relative = 1;

View File

@ -609,7 +609,7 @@ static void wt_status_collect_changes_index(struct wt_status *s)
init_revisions(&rev, NULL); init_revisions(&rev, NULL);
memset(&opt, 0, sizeof(opt)); memset(&opt, 0, sizeof(opt));
opt.def = s->is_initial ? EMPTY_TREE_SHA1_HEX : s->reference; opt.def = s->is_initial ? empty_tree_oid_hex() : s->reference;
setup_revisions(0, NULL, &rev, &opt); setup_revisions(0, NULL, &rev, &opt);
rev.diffopt.flags.override_submodule_config = 1; rev.diffopt.flags.override_submodule_config = 1;
@ -987,7 +987,7 @@ static void wt_longstatus_print_verbose(struct wt_status *s)
rev.diffopt.ita_invisible_in_index = 1; rev.diffopt.ita_invisible_in_index = 1;
memset(&opt, 0, sizeof(opt)); memset(&opt, 0, sizeof(opt));
opt.def = s->is_initial ? EMPTY_TREE_SHA1_HEX : s->reference; opt.def = s->is_initial ? empty_tree_oid_hex() : s->reference;
setup_revisions(0, NULL, &rev, &opt); setup_revisions(0, NULL, &rev, &opt);
rev.diffopt.output_format |= DIFF_FORMAT_PATCH; rev.diffopt.output_format |= DIFF_FORMAT_PATCH;