kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

fast-import: convert to struct object_id 

Convert the remaining parts of fast-import.c to use struct object_id.
Convert several instances of get_sha1_hex to parse_oid_hex to avoid
needing to specify constants.  Convert other hardcoded values to named
constants.  Finally, use the is_empty_tree_oid function instead of a
direct comparison against a fixed string.

Note that the odd computation with GIT_MAX_HEXSZ is due to the insertion
of a slash between every two hex digits in the path, plus one for the
terminating NUL.

Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
brian m. carlson 2017-05-06 22:09:56 +00:00 committed by Junio C Hamano
parent d7e6b6a8dc
commit 912c13d58f
1 changed files with 159 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

317
fast-import.c
View File

@ -557,7 +557,7 @@ static void alloc_objects(unsigned int cnt)
alloc_count += cnt; alloc_count += cnt;
} }


static struct object_entry *new_object(unsigned char *sha1) static struct object_entry *new_object(struct object_id *oid)
{ {
struct object_entry *e; struct object_entry *e;


@ -565,32 +565,32 @@ static struct object_entry *new_object(unsigned char *sha1)
alloc_objects(object_entry_alloc); alloc_objects(object_entry_alloc);


e = blocks->next_free++; e = blocks->next_free++;
hashcpy(e->idx.sha1, sha1); hashcpy(e->idx.sha1, oid->hash);
return e; return e;
} }


static struct object_entry *find_object(unsigned char *sha1) static struct object_entry *find_object(struct object_id *oid)
{ {
unsigned int h = sha1[0] << 8 | sha1[1]; unsigned int h = oid->hash[0] << 8 | oid->hash[1];
struct object_entry *e; struct object_entry *e;
for (e = object_table[h]; e; e = e->next) for (e = object_table[h]; e; e = e->next)
if (!hashcmp(sha1, e->idx.sha1)) if (!hashcmp(oid->hash, e->idx.sha1))
return e; return e;
return NULL; return NULL;
} }


static struct object_entry *insert_object(unsigned char *sha1) static struct object_entry *insert_object(struct object_id *oid)
{ {
unsigned int h = sha1[0] << 8 | sha1[1]; unsigned int h = oid->hash[0] << 8 | oid->hash[1];
struct object_entry *e = object_table[h]; struct object_entry *e = object_table[h];


while (e) { while (e) {
if (!hashcmp(sha1, e->idx.sha1)) if (!hashcmp(oid->hash, e->idx.sha1))
return e; return e;
e = e->next; e = e->next;
} }


e = new_object(sha1); e = new_object(oid);
e->next = object_table[h]; e->next = object_table[h];
e->idx.offset = 0; e->idx.offset = 0;
object_table[h] = e; object_table[h] = e;
@ -1007,17 +1007,17 @@ static void end_packfile(void)
clear_delta_base_cache(); clear_delta_base_cache();
if (object_count) { if (object_count) {
struct packed_git *new_p; struct packed_git *new_p;
unsigned char cur_pack_sha1[20]; struct object_id cur_pack_oid;
char *idx_name; char *idx_name;
int i; int i;
struct branch *b; struct branch *b;
struct tag *t; struct tag *t;


close_pack_windows(pack_data); close_pack_windows(pack_data);
sha1close(pack_file, cur_pack_sha1, 0); sha1close(pack_file, cur_pack_oid.hash, 0);
fixup_pack_header_footer(pack_data->pack_fd, pack_data->sha1, fixup_pack_header_footer(pack_data->pack_fd, pack_data->sha1,
pack_data->pack_name, object_count, pack_data->pack_name, object_count,
cur_pack_sha1, pack_size); cur_pack_oid.hash, pack_size);


if (object_count <= unpack_limit) { if (object_count <= unpack_limit) {
if (!loosen_small_pack(pack_data)) { if (!loosen_small_pack(pack_data)) {
@ -1083,13 +1083,13 @@ static int store_object(
enum object_type type, enum object_type type,
struct strbuf *dat, struct strbuf *dat,
struct last_object *last, struct last_object *last,
unsigned char *sha1out, struct object_id *oidout,
uintmax_t mark) uintmax_t mark)
{ {
void *out, *delta; void *out, *delta;
struct object_entry *e; struct object_entry *e;
unsigned char hdr[96]; unsigned char hdr[96];
unsigned char sha1[20]; struct object_id oid;
unsigned long hdrlen, deltalen; unsigned long hdrlen, deltalen;
git_SHA_CTX c; git_SHA_CTX c;
git_zstream s; git_zstream s;
@ -1099,17 +1099,17 @@ static int store_object(
git_SHA1_Init(&c); git_SHA1_Init(&c);
git_SHA1_Update(&c, hdr, hdrlen); git_SHA1_Update(&c, hdr, hdrlen);
git_SHA1_Update(&c, dat->buf, dat->len); git_SHA1_Update(&c, dat->buf, dat->len);
git_SHA1_Final(sha1, &c); git_SHA1_Final(oid.hash, &c);
if (sha1out) if (oidout)
hashcpy(sha1out, sha1); oidcpy(oidout, &oid);


e = insert_object(sha1); e = insert_object(&oid);
if (mark) if (mark)
insert_mark(mark, e); insert_mark(mark, e);
if (e->idx.offset) { if (e->idx.offset) {
duplicate_count_by_type[type]++; duplicate_count_by_type[type]++;
return 1; return 1;
} else if (find_sha1_pack(sha1, packed_git)) { } else if (find_sha1_pack(oid.hash, packed_git)) {
e->type = type; e->type = type;
e->pack_id = MAX_PACK_ID; e->pack_id = MAX_PACK_ID;
e->idx.offset = 1; /* just not zero! */ e->idx.offset = 1; /* just not zero! */
@ -1222,13 +1222,13 @@ static void truncate_pack(struct sha1file_checkpoint *checkpoint)
pack_size = checkpoint->offset; pack_size = checkpoint->offset;
} }


static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark) static void stream_blob(uintmax_t len, struct object_id *oidout, uintmax_t mark)
{ {
size_t in_sz = 64 * 1024, out_sz = 64 * 1024; size_t in_sz = 64 * 1024, out_sz = 64 * 1024;
unsigned char *in_buf = xmalloc(in_sz); unsigned char *in_buf = xmalloc(in_sz);
unsigned char *out_buf = xmalloc(out_sz); unsigned char *out_buf = xmalloc(out_sz);
struct object_entry *e; struct object_entry *e;
unsigned char sha1[20]; struct object_id oid;
unsigned long hdrlen; unsigned long hdrlen;
off_t offset; off_t offset;
git_SHA_CTX c; git_SHA_CTX c;
@ -1291,12 +1291,12 @@ static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark)
} }
} }
git_deflate_end(&s); git_deflate_end(&s);
git_SHA1_Final(sha1, &c); git_SHA1_Final(oid.hash, &c);


if (sha1out) if (oidout)
hashcpy(sha1out, sha1); oidcpy(oidout, &oid);


e = insert_object(sha1); e = insert_object(&oid);


if (mark) if (mark)
insert_mark(mark, e); insert_mark(mark, e);
@ -1305,7 +1305,7 @@ static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark)
duplicate_count_by_type[OBJ_BLOB]++; duplicate_count_by_type[OBJ_BLOB]++;
truncate_pack(&checkpoint); truncate_pack(&checkpoint);


} else if (find_sha1_pack(sha1, packed_git)) { } else if (find_sha1_pack(oid.hash, packed_git)) {
e->type = OBJ_BLOB; e->type = OBJ_BLOB;
e->pack_id = MAX_PACK_ID; e->pack_id = MAX_PACK_ID;
e->idx.offset = 1; /* just not zero! */ e->idx.offset = 1; /* just not zero! */
@ -1389,7 +1389,7 @@ static const char *get_mode(const char *str, uint16_t *modep)


static void load_tree(struct tree_entry *root) static void load_tree(struct tree_entry *root)
{ {
unsigned char *sha1 = root->versions[1].oid.hash; struct object_id *oid = &root->versions[1].oid;
struct object_entry *myoe; struct object_entry *myoe;
struct tree_content *t; struct tree_content *t;
unsigned long size; unsigned long size;
@ -1397,22 +1397,22 @@ static void load_tree(struct tree_entry *root)
const char *c; const char *c;


root->tree = t = new_tree_content(8); root->tree = t = new_tree_content(8);
if (is_null_sha1(sha1)) if (is_null_oid(oid))
return; return;


myoe = find_object(sha1); myoe = find_object(oid);
if (myoe && myoe->pack_id != MAX_PACK_ID) { if (myoe && myoe->pack_id != MAX_PACK_ID) {
if (myoe->type != OBJ_TREE) if (myoe->type != OBJ_TREE)
die("Not a tree: %s", sha1_to_hex(sha1)); die("Not a tree: %s", oid_to_hex(oid));
t->delta_depth = myoe->depth; t->delta_depth = myoe->depth;
buf = gfi_unpack_entry(myoe, &size); buf = gfi_unpack_entry(myoe, &size);
if (!buf) if (!buf)
die("Can't load tree %s", sha1_to_hex(sha1)); die("Can't load tree %s", oid_to_hex(oid));
} else { } else {
enum object_type type; enum object_type type;
buf = read_sha1_file(sha1, &type, &size); buf = read_sha1_file(oid->hash, &type, &size);
if (!buf || type != OBJ_TREE) if (!buf || type != OBJ_TREE)
die("Can't load tree %s", sha1_to_hex(sha1)); die("Can't load tree %s", oid_to_hex(oid));
} }


c = buf; c = buf;
@ -1426,13 +1426,13 @@ static void load_tree(struct tree_entry *root)
e->tree = NULL; e->tree = NULL;
c = get_mode(c, &e->versions[1].mode); c = get_mode(c, &e->versions[1].mode);
if (!c) if (!c)
die("Corrupt mode in %s", sha1_to_hex(sha1)); die("Corrupt mode in %s", oid_to_hex(oid));
e->versions[0].mode = e->versions[1].mode; e->versions[0].mode = e->versions[1].mode;
e->name = to_atom(c, strlen(c)); e->name = to_atom(c, strlen(c));
c += e->name->str_len + 1; c += e->name->str_len + 1;
hashcpy(e->versions[0].oid.hash, (unsigned char *)c); hashcpy(e->versions[0].oid.hash, (unsigned char *)c);
hashcpy(e->versions[1].oid.hash, (unsigned char *)c); hashcpy(e->versions[1].oid.hash, (unsigned char *)c);
c += 20; c += GIT_SHA1_RAWSZ;
} }
free(buf); free(buf);
} }
@ -1479,7 +1479,7 @@ static void mktree(struct tree_content *t, int v, struct strbuf *b)
strbuf_addf(b, "%o %s%c", strbuf_addf(b, "%o %s%c",
(unsigned int)(e->versions[v].mode & ~NO_DELTA), (unsigned int)(e->versions[v].mode & ~NO_DELTA),
e->name->str_dat, '\0'); e->name->str_dat, '\0');
strbuf_add(b, e->versions[v].oid.hash, 20); strbuf_add(b, e->versions[v].oid.hash, GIT_SHA1_RAWSZ);
} }
} }


@ -1503,7 +1503,7 @@ static void store_tree(struct tree_entry *root)
} }


if (!(root->versions[0].mode & NO_DELTA)) if (!(root->versions[0].mode & NO_DELTA))
le = find_object(root->versions[0].oid.hash); le = find_object(&root->versions[0].oid);
if (S_ISDIR(root->versions[0].mode) && le && le->pack_id == pack_id) { if (S_ISDIR(root->versions[0].mode) && le && le->pack_id == pack_id) {
mktree(t, 0, &old_tree); mktree(t, 0, &old_tree);
lo.data = old_tree; lo.data = old_tree;
@ -1512,7 +1512,7 @@ static void store_tree(struct tree_entry *root)
} }


mktree(t, 1, &new_tree); mktree(t, 1, &new_tree);
store_object(OBJ_TREE, &new_tree, &lo, root->versions[1].oid.hash, 0); store_object(OBJ_TREE, &new_tree, &lo, &root->versions[1].oid, 0);


t->delta_depth = lo.depth; t->delta_depth = lo.depth;
for (i = 0, j = 0, del = 0; i < t->entry_count; i++) { for (i = 0, j = 0, del = 0; i < t->entry_count; i++) {
@ -1531,14 +1531,14 @@ static void store_tree(struct tree_entry *root)


static void tree_content_replace( static void tree_content_replace(
struct tree_entry *root, struct tree_entry *root,
const unsigned char *sha1, const struct object_id *oid,
const uint16_t mode, const uint16_t mode,
struct tree_content *newtree) struct tree_content *newtree)
{ {
if (!S_ISDIR(mode)) if (!S_ISDIR(mode))
die("Root cannot be a non-directory"); die("Root cannot be a non-directory");
oidclr(&root->versions[0].oid); oidclr(&root->versions[0].oid);
hashcpy(root->versions[1].oid.hash, sha1); oidcpy(&root->versions[1].oid, oid);
if (root->tree) if (root->tree)
release_tree_content_recursive(root->tree); release_tree_content_recursive(root->tree);
root->tree = newtree; root->tree = newtree;
@ -1547,7 +1547,7 @@ static void tree_content_replace(
static int tree_content_set( static int tree_content_set(
struct tree_entry *root, struct tree_entry *root,
const char *p, const char *p,
const unsigned char *sha1, const struct object_id *oid,
const uint16_t mode, const uint16_t mode,
struct tree_content *subtree) struct tree_content *subtree)
{ {
@ -1572,10 +1572,10 @@ static int tree_content_set(
if (!*slash1) { if (!*slash1) {
if (!S_ISDIR(mode) if (!S_ISDIR(mode)
&& e->versions[1].mode == mode && e->versions[1].mode == mode
&& !hashcmp(e->versions[1].oid.hash, sha1)) && !oidcmp(&e->versions[1].oid, oid))
return 0; return 0;
e->versions[1].mode = mode; e->versions[1].mode = mode;
hashcpy(e->versions[1].oid.hash, sha1); oidcpy(&e->versions[1].oid, oid);
if (e->tree) if (e->tree)
release_tree_content_recursive(e->tree); release_tree_content_recursive(e->tree);
e->tree = subtree; e->tree = subtree;
@ -1605,7 +1605,7 @@ static int tree_content_set(
} }
if (!e->tree) if (!e->tree)
load_tree(e); load_tree(e);
if (tree_content_set(e, slash1 + 1, sha1, mode, subtree)) { if (tree_content_set(e, slash1 + 1, oid, mode, subtree)) {
oidclr(&root->versions[1].oid); oidclr(&root->versions[1].oid);
return 1; return 1;
} }
@ -1623,11 +1623,11 @@ static int tree_content_set(
if (*slash1) { if (*slash1) {
e->tree = new_tree_content(8); e->tree = new_tree_content(8);
e->versions[1].mode = S_IFDIR; e->versions[1].mode = S_IFDIR;
tree_content_set(e, slash1 + 1, sha1, mode, subtree); tree_content_set(e, slash1 + 1, oid, mode, subtree);
} else { } else {
e->tree = subtree; e->tree = subtree;
e->versions[1].mode = mode; e->versions[1].mode = mode;
hashcpy(e->versions[1].oid.hash, sha1); oidcpy(&e->versions[1].oid, oid);
} }
oidclr(&root->versions[1].oid); oidclr(&root->versions[1].oid);
return 1; return 1;
@ -1750,7 +1750,7 @@ static int update_branch(struct branch *b)
{ {
static const char *msg = "fast-import"; static const char *msg = "fast-import";
struct ref_transaction *transaction; struct ref_transaction *transaction;
unsigned char old_sha1[20]; struct object_id old_oid;
struct strbuf err = STRBUF_INIT; struct strbuf err = STRBUF_INIT;


if (is_null_oid(&b->oid)) { if (is_null_oid(&b->oid)) {
@ -1758,12 +1758,12 @@ static int update_branch(struct branch *b)
delete_ref(NULL, b->name, NULL, 0); delete_ref(NULL, b->name, NULL, 0);
return 0; return 0;
} }
if (read_ref(b->name, old_sha1)) if (read_ref(b->name, old_oid.hash))
hashclr(old_sha1); oidclr(&old_oid);
if (!force_update && !is_null_sha1(old_sha1)) { if (!force_update && !is_null_oid(&old_oid)) {
struct commit *old_cmit, *new_cmit; struct commit *old_cmit, *new_cmit;


old_cmit = lookup_commit_reference_gently(old_sha1, 0); old_cmit = lookup_commit_reference_gently(old_oid.hash, 0);
new_cmit = lookup_commit_reference_gently(b->oid.hash, 0); new_cmit = lookup_commit_reference_gently(b->oid.hash, 0);
if (!old_cmit || !new_cmit) if (!old_cmit || !new_cmit)
return error("Branch %s is missing commits.", b->name); return error("Branch %s is missing commits.", b->name);
@ -1772,13 +1772,13 @@ static int update_branch(struct branch *b)
warning("Not updating %s" warning("Not updating %s"
" (new tip %s does not contain %s)", " (new tip %s does not contain %s)",
b->name, oid_to_hex(&b->oid), b->name, oid_to_hex(&b->oid),
sha1_to_hex(old_sha1)); oid_to_hex(&old_oid));
return -1; return -1;
} }
} }
transaction = ref_transaction_begin(&err); transaction = ref_transaction_begin(&err);
if (!transaction || if (!transaction ||
ref_transaction_update(transaction, b->name, b->oid.hash, old_sha1, ref_transaction_update(transaction, b->name, b->oid.hash, old_oid.hash,
0, msg, &err) || 0, msg, &err) ||
ref_transaction_commit(transaction, &err)) { ref_transaction_commit(transaction, &err)) {
ref_transaction_free(transaction); ref_transaction_free(transaction);
@ -1898,7 +1898,7 @@ static void read_marks(void)
while (fgets(line, sizeof(line), f)) { while (fgets(line, sizeof(line), f)) {
uintmax_t mark; uintmax_t mark;
char *end; char *end;
unsigned char sha1[20]; struct object_id oid;
struct object_entry *e; struct object_entry *e;


end = strchr(line, '\n'); end = strchr(line, '\n');
@ -1907,14 +1907,14 @@ static void read_marks(void)
*end = 0; *end = 0;
mark = strtoumax(line + 1, &end, 10); mark = strtoumax(line + 1, &end, 10);
if (!mark || end == line + 1 if (!mark || end == line + 1
|| *end != ' ' || get_sha1_hex(end + 1, sha1)) || *end != ' ' || get_oid_hex(end + 1, &oid))
die("corrupt mark line: %s", line); die("corrupt mark line: %s", line);
e = find_object(sha1); e = find_object(&oid);
if (!e) { if (!e) {
enum object_type type = sha1_object_info(sha1, NULL); enum object_type type = sha1_object_info(oid.hash, NULL);
if (type < 0) if (type < 0)
die("object not found: %s", sha1_to_hex(sha1)); die("object not found: %s", oid_to_hex(&oid));
e = insert_object(sha1); e = insert_object(&oid);
e->type = type; e->type = type;
e->pack_id = MAX_PACK_ID; e->pack_id = MAX_PACK_ID;
e->idx.offset = 1; /* just not zero! */ e->idx.offset = 1; /* just not zero! */
@ -2122,21 +2122,21 @@ static char *parse_ident(const char *buf)


static void parse_and_store_blob( static void parse_and_store_blob(
struct last_object *last, struct last_object *last,
unsigned char *sha1out, struct object_id *oidout,
uintmax_t mark) uintmax_t mark)
{ {
static struct strbuf buf = STRBUF_INIT; static struct strbuf buf = STRBUF_INIT;
uintmax_t len; uintmax_t len;


if (parse_data(&buf, big_file_threshold, &len)) if (parse_data(&buf, big_file_threshold, &len))
store_object(OBJ_BLOB, &buf, last, sha1out, mark); store_object(OBJ_BLOB, &buf, last, oidout, mark);
else { else {
if (last) { if (last) {
strbuf_release(&last->data); strbuf_release(&last->data);
last->offset = 0; last->offset = 0;
last->depth = 0; last->depth = 0;
} }
stream_blob(len, sha1out, mark); stream_blob(len, oidout, mark);
skip_optional_lf(); skip_optional_lf();
} }
} }
@ -2212,21 +2212,21 @@ static void construct_path_with_fanout(const char *hex_sha1,
path[i++] = '/'; path[i++] = '/';
fanout--; fanout--;
} }
memcpy(path + i, hex_sha1 + j, 40 - j); memcpy(path + i, hex_sha1 + j, GIT_SHA1_HEXSZ - j);
path[i + 40 - j] = '\0'; path[i + GIT_SHA1_HEXSZ - j] = '\0';
} }


static uintmax_t do_change_note_fanout( static uintmax_t do_change_note_fanout(
struct tree_entry *orig_root, struct tree_entry *root, struct tree_entry *orig_root, struct tree_entry *root,
char *hex_sha1, unsigned int hex_sha1_len, char *hex_oid, unsigned int hex_oid_len,
char *fullpath, unsigned int fullpath_len, char *fullpath, unsigned int fullpath_len,
unsigned char fanout) unsigned char fanout)
{ {
struct tree_content *t; struct tree_content *t;
struct tree_entry *e, leaf; struct tree_entry *e, leaf;
unsigned int i, tmp_hex_sha1_len, tmp_fullpath_len; unsigned int i, tmp_hex_oid_len, tmp_fullpath_len;
uintmax_t num_notes = 0; uintmax_t num_notes = 0;
unsigned char sha1[20]; struct object_id oid;
char realpath[60]; char realpath[60];


if (!root->tree) if (!root->tree)
@ -2235,7 +2235,7 @@ static uintmax_t do_change_note_fanout(


for (i = 0; t && i < t->entry_count; i++) { for (i = 0; t && i < t->entry_count; i++) {
e = t->entries[i]; e = t->entries[i];
tmp_hex_sha1_len = hex_sha1_len + e->name->str_len; tmp_hex_oid_len = hex_oid_len + e->name->str_len;
tmp_fullpath_len = fullpath_len; tmp_fullpath_len = fullpath_len;


/* /*
@ -2247,12 +2247,12 @@ static uintmax_t do_change_note_fanout(
* of 2 chars. * of 2 chars.
*/ */
if (!e->versions[1].mode || if (!e->versions[1].mode ||
tmp_hex_sha1_len > 40 || tmp_hex_oid_len > GIT_SHA1_HEXSZ ||
e->name->str_len % 2) e->name->str_len % 2)
continue; continue;


/* This _may_ be a note entry, or a subdir containing notes */ /* This _may_ be a note entry, or a subdir containing notes */
memcpy(hex_sha1 + hex_sha1_len, e->name->str_dat, memcpy(hex_oid + hex_oid_len, e->name->str_dat,
e->name->str_len); e->name->str_len);
if (tmp_fullpath_len) if (tmp_fullpath_len)
fullpath[tmp_fullpath_len++] = '/'; fullpath[tmp_fullpath_len++] = '/';
@ -2261,14 +2261,14 @@ static uintmax_t do_change_note_fanout(
tmp_fullpath_len += e->name->str_len; tmp_fullpath_len += e->name->str_len;
fullpath[tmp_fullpath_len] = '\0'; fullpath[tmp_fullpath_len] = '\0';


if (tmp_hex_sha1_len == 40 && !get_sha1_hex(hex_sha1, sha1)) { if (tmp_hex_oid_len == GIT_SHA1_HEXSZ && !get_oid_hex(hex_oid, &oid)) {
/* This is a note entry */ /* This is a note entry */
if (fanout == 0xff) { if (fanout == 0xff) {
/* Counting mode, no rename */ /* Counting mode, no rename */
num_notes++; num_notes++;
continue; continue;
} }
construct_path_with_fanout(hex_sha1, fanout, realpath); construct_path_with_fanout(hex_oid, fanout, realpath);
if (!strcmp(fullpath, realpath)) { if (!strcmp(fullpath, realpath)) {
/* Note entry is in correct location */ /* Note entry is in correct location */
num_notes++; num_notes++;
@ -2279,13 +2279,13 @@ static uintmax_t do_change_note_fanout(
if (!tree_content_remove(orig_root, fullpath, &leaf, 0)) if (!tree_content_remove(orig_root, fullpath, &leaf, 0))
die("Failed to remove path %s", fullpath); die("Failed to remove path %s", fullpath);
tree_content_set(orig_root, realpath, tree_content_set(orig_root, realpath,
leaf.versions[1].oid.hash, &leaf.versions[1].oid,
leaf.versions[1].mode, leaf.versions[1].mode,
leaf.tree); leaf.tree);
} else if (S_ISDIR(e->versions[1].mode)) { } else if (S_ISDIR(e->versions[1].mode)) {
/* This is a subdir that may contain note entries */ /* This is a subdir that may contain note entries */
num_notes += do_change_note_fanout(orig_root, e, num_notes += do_change_note_fanout(orig_root, e,
hex_sha1, tmp_hex_sha1_len, hex_oid, tmp_hex_oid_len,
fullpath, tmp_fullpath_len, fanout); fullpath, tmp_fullpath_len, fanout);
} }


@ -2298,8 +2298,14 @@ static uintmax_t do_change_note_fanout(
static uintmax_t change_note_fanout(struct tree_entry *root, static uintmax_t change_note_fanout(struct tree_entry *root,
unsigned char fanout) unsigned char fanout)
{ {
char hex_sha1[40], path[60]; /*
return do_change_note_fanout(root, root, hex_sha1, 0, path, 0, fanout); * The size of path is due to one slash between every two hex digits,
* plus the terminating NUL. Note that there is no slash at the end, so
* the number of slashes is one less than half the number of hex
* characters.
*/
char hex_oid[GIT_MAX_HEXSZ], path[GIT_MAX_HEXSZ + (GIT_MAX_HEXSZ / 2) - 1 + 1];
return do_change_note_fanout(root, root, hex_oid, 0, path, 0, fanout);
} }


/* /*
@ -2360,7 +2366,7 @@ static void file_change_m(const char *p, struct branch *b)
static struct strbuf uq = STRBUF_INIT; static struct strbuf uq = STRBUF_INIT;
const char *endp; const char *endp;
struct object_entry *oe; struct object_entry *oe;
unsigned char sha1[20]; struct object_id oid;
uint16_t mode, inline_data = 0; uint16_t mode, inline_data = 0;


p = get_mode(p, &mode); p = get_mode(p, &mode);
@ -2383,15 +2389,14 @@ static void file_change_m(const char *p, struct branch *b)


if (*p == ':') { if (*p == ':') {
oe = find_mark(parse_mark_ref_space(&p)); oe = find_mark(parse_mark_ref_space(&p));
hashcpy(sha1, oe->idx.sha1); hashcpy(oid.hash, oe->idx.sha1);
} else if (skip_prefix(p, "inline ", &p)) { } else if (skip_prefix(p, "inline ", &p)) {
inline_data = 1; inline_data = 1;
oe = NULL; /* not used with inline_data, but makes gcc happy */ oe = NULL; /* not used with inline_data, but makes gcc happy */
} else { } else {
if (get_sha1_hex(p, sha1)) if (parse_oid_hex(p, &oid, &p))
die("Invalid dataref: %s", command_buf.buf); die("Invalid dataref: %s", command_buf.buf);
oe = find_object(sha1); oe = find_object(&oid);
p += 40;
if (*p++ != ' ') if (*p++ != ' ')
die("Missing space after SHA1: %s", command_buf.buf); die("Missing space after SHA1: %s", command_buf.buf);
} }
@ -2404,7 +2409,7 @@ static void file_change_m(const char *p, struct branch *b)
} }


/* Git does not track empty, non-toplevel directories. */ /* Git does not track empty, non-toplevel directories. */
if (S_ISDIR(mode) && !hashcmp(sha1, EMPTY_TREE_SHA1_BIN) && *p) { if (S_ISDIR(mode) && is_empty_tree_oid(&oid) && *p) {
tree_content_remove(&b->branch_tree, p, NULL, 0); tree_content_remove(&b->branch_tree, p, NULL, 0);
return; return;
} }
@ -2431,12 +2436,12 @@ static void file_change_m(const char *p, struct branch *b)
p = uq.buf; p = uq.buf;
} }
read_next_command(); read_next_command();
parse_and_store_blob(&last_blob, sha1, 0); parse_and_store_blob(&last_blob, &oid, 0);
} else { } else {
enum object_type expected = S_ISDIR(mode) ? enum object_type expected = S_ISDIR(mode) ?
OBJ_TREE: OBJ_BLOB; OBJ_TREE: OBJ_BLOB;
enum object_type type = oe ? oe->type : enum object_type type = oe ? oe->type :
sha1_object_info(sha1, NULL); sha1_object_info(oid.hash, NULL);
if (type < 0) if (type < 0)
die("%s not found: %s", die("%s not found: %s",
S_ISDIR(mode) ? "Tree" : "Blob", S_ISDIR(mode) ? "Tree" : "Blob",
@ -2448,10 +2453,10 @@ static void file_change_m(const char *p, struct branch *b)
} }


if (!*p) { if (!*p) {
tree_content_replace(&b->branch_tree, sha1, mode, NULL); tree_content_replace(&b->branch_tree, &oid, mode, NULL);
return; return;
} }
tree_content_set(&b->branch_tree, p, sha1, mode, NULL); tree_content_set(&b->branch_tree, p, &oid, mode, NULL);
} }


static void file_change_d(const char *p, struct branch *b) static void file_change_d(const char *p, struct branch *b)
@ -2509,13 +2514,13 @@ static void file_change_cr(const char *s, struct branch *b, int rename)
die("Path %s not in branch", s); die("Path %s not in branch", s);
if (!*d) { /* C "path/to/subdir" "" */ if (!*d) { /* C "path/to/subdir" "" */
tree_content_replace(&b->branch_tree, tree_content_replace(&b->branch_tree,
leaf.versions[1].oid.hash, &leaf.versions[1].oid,
leaf.versions[1].mode, leaf.versions[1].mode,
leaf.tree); leaf.tree);
return; return;
} }
tree_content_set(&b->branch_tree, d, tree_content_set(&b->branch_tree, d,
leaf.versions[1].oid.hash, &leaf.versions[1].oid,
leaf.versions[1].mode, leaf.versions[1].mode,
leaf.tree); leaf.tree);
} }
@ -2525,7 +2530,7 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa
static struct strbuf uq = STRBUF_INIT; static struct strbuf uq = STRBUF_INIT;
struct object_entry *oe; struct object_entry *oe;
struct branch *s; struct branch *s;
unsigned char sha1[20], commit_sha1[20]; struct object_id oid, commit_oid;
char path[60]; char path[60];
uint16_t inline_data = 0; uint16_t inline_data = 0;
unsigned char new_fanout; unsigned char new_fanout;
@ -2550,15 +2555,14 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa
/* <dataref> or 'inline' */ /* <dataref> or 'inline' */
if (*p == ':') { if (*p == ':') {
oe = find_mark(parse_mark_ref_space(&p)); oe = find_mark(parse_mark_ref_space(&p));
hashcpy(sha1, oe->idx.sha1); hashcpy(oid.hash, oe->idx.sha1);
} else if (skip_prefix(p, "inline ", &p)) { } else if (skip_prefix(p, "inline ", &p)) {
inline_data = 1; inline_data = 1;
oe = NULL; /* not used with inline_data, but makes gcc happy */ oe = NULL; /* not used with inline_data, but makes gcc happy */
} else { } else {
if (get_sha1_hex(p, sha1)) if (parse_oid_hex(p, &oid, &p))
die("Invalid dataref: %s", command_buf.buf); die("Invalid dataref: %s", command_buf.buf);
oe = find_object(sha1); oe = find_object(&oid);
p += 40;
if (*p++ != ' ') if (*p++ != ' ')
die("Missing space after SHA1: %s", command_buf.buf); die("Missing space after SHA1: %s", command_buf.buf);
} }
@ -2568,17 +2572,17 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa
if (s) { if (s) {
if (is_null_oid(&s->oid)) if (is_null_oid(&s->oid))
die("Can't add a note on empty branch."); die("Can't add a note on empty branch.");
hashcpy(commit_sha1, s->oid.hash); oidcpy(&commit_oid, &s->oid);
} else if (*p == ':') { } else if (*p == ':') {
uintmax_t commit_mark = parse_mark_ref_eol(p); uintmax_t commit_mark = parse_mark_ref_eol(p);
struct object_entry *commit_oe = find_mark(commit_mark); struct object_entry *commit_oe = find_mark(commit_mark);
if (commit_oe->type != OBJ_COMMIT) if (commit_oe->type != OBJ_COMMIT)
die("Mark :%" PRIuMAX " not a commit", commit_mark); die("Mark :%" PRIuMAX " not a commit", commit_mark);
hashcpy(commit_sha1, commit_oe->idx.sha1); hashcpy(commit_oid.hash, commit_oe->idx.sha1);
} else if (!get_sha1(p, commit_sha1)) { } else if (!get_oid(p, &commit_oid)) {
unsigned long size; unsigned long size;
char *buf = read_object_with_reference(commit_sha1, char *buf = read_object_with_reference(commit_oid.hash,
commit_type, &size, commit_sha1); commit_type, &size, commit_oid.hash);
if (!buf || size < 46) if (!buf || size < 46)
die("Not a valid commit: %s", p); die("Not a valid commit: %s", p);
free(buf); free(buf);
@ -2591,13 +2595,13 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa
p = uq.buf; p = uq.buf;
} }
read_next_command(); read_next_command();
parse_and_store_blob(&last_blob, sha1, 0); parse_and_store_blob(&last_blob, &oid, 0);
} else if (oe) { } else if (oe) {
if (oe->type != OBJ_BLOB) if (oe->type != OBJ_BLOB)
die("Not a blob (actually a %s): %s", die("Not a blob (actually a %s): %s",
typename(oe->type), command_buf.buf); typename(oe->type), command_buf.buf);
} else if (!is_null_sha1(sha1)) { } else if (!is_null_oid(&oid)) {
enum object_type type = sha1_object_info(sha1, NULL); enum object_type type = sha1_object_info(oid.hash, NULL);
if (type < 0) if (type < 0)
die("Blob not found: %s", command_buf.buf); die("Blob not found: %s", command_buf.buf);
if (type != OBJ_BLOB) if (type != OBJ_BLOB)
@ -2605,17 +2609,17 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa
typename(type), command_buf.buf); typename(type), command_buf.buf);
} }


construct_path_with_fanout(sha1_to_hex(commit_sha1), *old_fanout, path); construct_path_with_fanout(oid_to_hex(&commit_oid), *old_fanout, path);
if (tree_content_remove(&b->branch_tree, path, NULL, 0)) if (tree_content_remove(&b->branch_tree, path, NULL, 0))
b->num_notes--; b->num_notes--;


if (is_null_sha1(sha1)) if (is_null_oid(&oid))
return; /* nothing to insert */ return; /* nothing to insert */


b->num_notes++; b->num_notes++;
new_fanout = convert_num_notes_to_fanout(b->num_notes); new_fanout = convert_num_notes_to_fanout(b->num_notes);
construct_path_with_fanout(sha1_to_hex(commit_sha1), new_fanout, path); construct_path_with_fanout(oid_to_hex(&commit_oid), new_fanout, path);
tree_content_set(&b->branch_tree, path, sha1, S_IFREG | 0644, NULL); tree_content_set(&b->branch_tree, path, &oid, S_IFREG | 0644, NULL);
} }


static void file_change_deleteall(struct branch *b) static void file_change_deleteall(struct branch *b)
@ -2629,10 +2633,10 @@ static void file_change_deleteall(struct branch *b)


static void parse_from_commit(struct branch *b, char *buf, unsigned long size) static void parse_from_commit(struct branch *b, char *buf, unsigned long size)
{ {
if (!buf || size < 46) if (!buf || size < GIT_SHA1_HEXSZ + 6)
die("Not a valid commit: %s", oid_to_hex(&b->oid)); die("Not a valid commit: %s", oid_to_hex(&b->oid));
if (memcmp("tree ", buf, 5) if (memcmp("tree ", buf, 5)
|| get_sha1_hex(buf + 5, b->branch_tree.versions[1].oid.hash)) || get_oid_hex(buf + 5, &b->branch_tree.versions[1].oid))
die("The commit %s is corrupt", oid_to_hex(&b->oid)); die("The commit %s is corrupt", oid_to_hex(&b->oid));
oidcpy(&b->branch_tree.versions[0].oid, oidcpy(&b->branch_tree.versions[0].oid,
&b->branch_tree.versions[1].oid); &b->branch_tree.versions[1].oid);
@ -2659,21 +2663,21 @@ static int parse_from(struct branch *b)
{ {
const char *from; const char *from;
struct branch *s; struct branch *s;
unsigned char sha1[20]; struct object_id oid;


if (!skip_prefix(command_buf.buf, "from ", &from)) if (!skip_prefix(command_buf.buf, "from ", &from))
return 0; return 0;


hashcpy(sha1, b->branch_tree.versions[1].oid.hash); oidcpy(&oid, &b->branch_tree.versions[1].oid);


s = lookup_branch(from); s = lookup_branch(from);
if (b == s) if (b == s)
die("Can't create a branch from itself: %s", b->name); die("Can't create a branch from itself: %s", b->name);
else if (s) { else if (s) {
unsigned char *t = s->branch_tree.versions[1].oid.hash; struct object_id *t = &s->branch_tree.versions[1].oid;
oidcpy(&b->oid, &s->oid); oidcpy(&b->oid, &s->oid);
hashcpy(b->branch_tree.versions[0].oid.hash, t); oidcpy(&b->branch_tree.versions[0].oid, t);
hashcpy(b->branch_tree.versions[1].oid.hash, t); oidcpy(&b->branch_tree.versions[1].oid, t);
} else if (*from == ':') { } else if (*from == ':') {
uintmax_t idnum = parse_mark_ref_eol(from); uintmax_t idnum = parse_mark_ref_eol(from);
struct object_entry *oe = find_mark(idnum); struct object_entry *oe = find_mark(idnum);
@ -2689,7 +2693,7 @@ static int parse_from(struct branch *b)
} else } else
parse_from_existing(b); parse_from_existing(b);
} }
} else if (!get_sha1(from, b->oid.hash)) { } else if (!get_oid(from, &b->oid)) {
parse_from_existing(b); parse_from_existing(b);
if (is_null_oid(&b->oid)) if (is_null_oid(&b->oid))
b->delete = 1; b->delete = 1;
@ -2697,7 +2701,7 @@ static int parse_from(struct branch *b)
else else
die("Invalid ref name or SHA1 expression: %s", from); die("Invalid ref name or SHA1 expression: %s", from);


if (b->branch_tree.tree && hashcmp(sha1, b->branch_tree.versions[1].oid.hash)) { if (b->branch_tree.tree && oidcmp(&oid, &b->branch_tree.versions[1].oid)) {
release_tree_content_recursive(b->branch_tree.tree); release_tree_content_recursive(b->branch_tree.tree);
b->branch_tree.tree = NULL; b->branch_tree.tree = NULL;
} }
@ -2724,12 +2728,10 @@ static struct hash_list *parse_merge(unsigned int *count)
if (oe->type != OBJ_COMMIT) if (oe->type != OBJ_COMMIT)
die("Mark :%" PRIuMAX " not a commit", idnum); die("Mark :%" PRIuMAX " not a commit", idnum);
hashcpy(n->oid.hash, oe->idx.sha1); hashcpy(n->oid.hash, oe->idx.sha1);
} else if (!get_sha1(from, n->oid.hash)) { } else if (!get_oid(from, &n->oid)) {
unsigned long size; unsigned long size;
char *buf = read_object_with_reference(n->oid.hash, char *buf = read_object_with_reference(n->oid.hash,
commit_type, commit_type, &size, n->oid.hash);
&size,
n->oid.hash);
if (!buf || size < 46) if (!buf || size < 46)
die("Not a valid commit: %s", from); die("Not a valid commit: %s", from);
free(buf); free(buf);
@ -2841,7 +2843,7 @@ static void parse_new_commit(const char *arg)
free(author); free(author);
free(committer); free(committer);


if (!store_object(OBJ_COMMIT, &new_data, NULL, b->oid.hash, next_mark)) if (!store_object(OBJ_COMMIT, &new_data, NULL, &b->oid, next_mark))
b->pack_id = pack_id; b->pack_id = pack_id;
b->last_commit = object_count_by_type[OBJ_COMMIT]; b->last_commit = object_count_by_type[OBJ_COMMIT];
} }
@ -2854,7 +2856,7 @@ static void parse_new_tag(const char *arg)
struct branch *s; struct branch *s;
struct tag *t; struct tag *t;
uintmax_t from_mark = 0; uintmax_t from_mark = 0;
unsigned char sha1[20]; struct object_id oid;
enum object_type type; enum object_type type;
const char *v; const char *v;


@ -2875,18 +2877,18 @@ static void parse_new_tag(const char *arg)
if (s) { if (s) {
if (is_null_oid(&s->oid)) if (is_null_oid(&s->oid))
die("Can't tag an empty branch."); die("Can't tag an empty branch.");
hashcpy(sha1, s->oid.hash); oidcpy(&oid, &s->oid);
type = OBJ_COMMIT; type = OBJ_COMMIT;
} else if (*from == ':') { } else if (*from == ':') {
struct object_entry *oe; struct object_entry *oe;
from_mark = parse_mark_ref_eol(from); from_mark = parse_mark_ref_eol(from);
oe = find_mark(from_mark); oe = find_mark(from_mark);
type = oe->type; type = oe->type;
hashcpy(sha1, oe->idx.sha1); hashcpy(oid.hash, oe->idx.sha1);
} else if (!get_sha1(from, sha1)) { } else if (!get_oid(from, &oid)) {
struct object_entry *oe = find_object(sha1); struct object_entry *oe = find_object(&oid);
if (!oe) { if (!oe) {
type = sha1_object_info(sha1, NULL); type = sha1_object_info(oid.hash, NULL);
if (type < 0) if (type < 0)
die("Not a valid object: %s", from); die("Not a valid object: %s", from);
} else } else
@ -2912,7 +2914,7 @@ static void parse_new_tag(const char *arg)
"object %s\n" "object %s\n"
"type %s\n" "type %s\n"
"tag %s\n", "tag %s\n",
sha1_to_hex(sha1), typename(type), t->name); oid_to_hex(&oid), typename(type), t->name);
if (tagger) if (tagger)
strbuf_addf(&new_data, strbuf_addf(&new_data,
"tagger %s\n", tagger); "tagger %s\n", tagger);
@ -2920,7 +2922,7 @@ static void parse_new_tag(const char *arg)
strbuf_addbuf(&new_data, &msg); strbuf_addbuf(&new_data, &msg);
free(tagger); free(tagger);


if (store_object(OBJ_TAG, &new_data, NULL, t->oid.hash, 0)) if (store_object(OBJ_TAG, &new_data, NULL, &t->oid, 0))
t->pack_id = MAX_PACK_ID; t->pack_id = MAX_PACK_ID;
else else
t->pack_id = pack_id; t->pack_id = pack_id;
@ -2954,7 +2956,7 @@ static void cat_blob_write(const char *buf, unsigned long size)
die_errno("Write to frontend failed"); die_errno("Write to frontend failed");
} }


static void cat_blob(struct object_entry *oe, unsigned char sha1[20]) static void cat_blob(struct object_entry *oe, struct object_id *oid)
{ {
struct strbuf line = STRBUF_INIT; struct strbuf line = STRBUF_INIT;
unsigned long size; unsigned long size;
@ -2962,7 +2964,7 @@ static void cat_blob(struct object_entry *oe, unsigned char sha1[20])
char *buf; char *buf;


if (!oe || oe->pack_id == MAX_PACK_ID) { if (!oe || oe->pack_id == MAX_PACK_ID) {
buf = read_sha1_file(sha1, &type, &size); buf = read_sha1_file(oid->hash, &type, &size);
} else { } else {
type = oe->type; type = oe->type;
buf = gfi_unpack_entry(oe, &size); buf = gfi_unpack_entry(oe, &size);
@ -2973,19 +2975,19 @@ static void cat_blob(struct object_entry *oe, unsigned char sha1[20])
*/ */
if (type <= 0) { if (type <= 0) {
strbuf_reset(&line); strbuf_reset(&line);
strbuf_addf(&line, "%s missing\n", sha1_to_hex(sha1)); strbuf_addf(&line, "%s missing\n", oid_to_hex(oid));
cat_blob_write(line.buf, line.len); cat_blob_write(line.buf, line.len);
strbuf_release(&line); strbuf_release(&line);
free(buf); free(buf);
return; return;
} }
if (!buf) if (!buf)
die("Can't read object %s", sha1_to_hex(sha1)); die("Can't read object %s", oid_to_hex(oid));
if (type != OBJ_BLOB) if (type != OBJ_BLOB)
die("Object %s is a %s but a blob was expected.", die("Object %s is a %s but a blob was expected.",
sha1_to_hex(sha1), typename(type)); oid_to_hex(oid), typename(type));
strbuf_reset(&line); strbuf_reset(&line);
strbuf_addf(&line, "%s %s %lu\n", sha1_to_hex(sha1), strbuf_addf(&line, "%s %s %lu\n", oid_to_hex(oid),
typename(type), size); typename(type), size);
cat_blob_write(line.buf, line.len); cat_blob_write(line.buf, line.len);
strbuf_release(&line); strbuf_release(&line);
@ -3002,7 +3004,7 @@ static void cat_blob(struct object_entry *oe, unsigned char sha1[20])
static void parse_get_mark(const char *p) static void parse_get_mark(const char *p)
{ {
struct object_entry *oe = oe; struct object_entry *oe = oe;
char output[42]; char output[GIT_MAX_HEXSZ + 2];


/* get-mark SP <object> LF */ /* get-mark SP <object> LF */
if (*p != ':') if (*p != ':')
@ -3013,42 +3015,42 @@ static void parse_get_mark(const char *p)
die("Unknown mark: %s", command_buf.buf); die("Unknown mark: %s", command_buf.buf);


xsnprintf(output, sizeof(output), "%s\n", sha1_to_hex(oe->idx.sha1)); xsnprintf(output, sizeof(output), "%s\n", sha1_to_hex(oe->idx.sha1));
cat_blob_write(output, 41); cat_blob_write(output, GIT_SHA1_HEXSZ + 1);
} }


static void parse_cat_blob(const char *p) static void parse_cat_blob(const char *p)
{ {
struct object_entry *oe = oe; struct object_entry *oe = oe;
unsigned char sha1[20]; struct object_id oid;


/* cat-blob SP <object> LF */ /* cat-blob SP <object> LF */
if (*p == ':') { if (*p == ':') {
oe = find_mark(parse_mark_ref_eol(p)); oe = find_mark(parse_mark_ref_eol(p));
if (!oe) if (!oe)
die("Unknown mark: %s", command_buf.buf); die("Unknown mark: %s", command_buf.buf);
hashcpy(sha1, oe->idx.sha1); hashcpy(oid.hash, oe->idx.sha1);
} else { } else {
if (get_sha1_hex(p, sha1)) if (parse_oid_hex(p, &oid, &p))
die("Invalid dataref: %s", command_buf.buf); die("Invalid dataref: %s", command_buf.buf);
if (p[40]) if (*p)
die("Garbage after SHA1: %s", command_buf.buf); die("Garbage after SHA1: %s", command_buf.buf);
oe = find_object(sha1); oe = find_object(&oid);
} }


cat_blob(oe, sha1); cat_blob(oe, &oid);
} }


static struct object_entry *dereference(struct object_entry *oe, static struct object_entry *dereference(struct object_entry *oe,
unsigned char sha1[20]) struct object_id *oid)
{ {
unsigned long size; unsigned long size;
char *buf = NULL; char *buf = NULL;
if (!oe) { if (!oe) {
enum object_type type = sha1_object_info(sha1, NULL); enum object_type type = sha1_object_info(oid->hash, NULL);
if (type < 0) if (type < 0)
die("object not found: %s", sha1_to_hex(sha1)); die("object not found: %s", oid_to_hex(oid));
/* cache it! */ /* cache it! */
oe = insert_object(sha1); oe = insert_object(oid);
oe->type = type; oe->type = type;
oe->pack_id = MAX_PACK_ID; oe->pack_id = MAX_PACK_ID;
oe->idx.offset = 1; oe->idx.offset = 1;
@ -3067,49 +3069,48 @@ static struct object_entry *dereference(struct object_entry *oe,
buf = gfi_unpack_entry(oe, &size); buf = gfi_unpack_entry(oe, &size);
} else { } else {
enum object_type unused; enum object_type unused;
buf = read_sha1_file(sha1, &unused, &size); buf = read_sha1_file(oid->hash, &unused, &size);
} }
if (!buf) if (!buf)
die("Can't load object %s", sha1_to_hex(sha1)); die("Can't load object %s", oid_to_hex(oid));


/* Peel one layer. */ /* Peel one layer. */
switch (oe->type) { switch (oe->type) {
case OBJ_TAG: case OBJ_TAG:
if (size < 40 + strlen("object ") || if (size < GIT_SHA1_HEXSZ + strlen("object ") ||
get_sha1_hex(buf + strlen("object "), sha1)) get_oid_hex(buf + strlen("object "), oid))
die("Invalid SHA1 in tag: %s", command_buf.buf); die("Invalid SHA1 in tag: %s", command_buf.buf);
break; break;
case OBJ_COMMIT: case OBJ_COMMIT:
if (size < 40 + strlen("tree ") || if (size < GIT_SHA1_HEXSZ + strlen("tree ") ||
get_sha1_hex(buf + strlen("tree "), sha1)) get_oid_hex(buf + strlen("tree "), oid))
die("Invalid SHA1 in commit: %s", command_buf.buf); die("Invalid SHA1 in commit: %s", command_buf.buf);
} }


free(buf); free(buf);
return find_object(sha1); return find_object(oid);
} }


static struct object_entry *parse_treeish_dataref(const char **p) static struct object_entry *parse_treeish_dataref(const char **p)
{ {
unsigned char sha1[20]; struct object_id oid;
struct object_entry *e; struct object_entry *e;


if (**p == ':') { /* <mark> */ if (**p == ':') { /* <mark> */
e = find_mark(parse_mark_ref_space(p)); e = find_mark(parse_mark_ref_space(p));
if (!e) if (!e)
die("Unknown mark: %s", command_buf.buf); die("Unknown mark: %s", command_buf.buf);
hashcpy(sha1, e->idx.sha1); hashcpy(oid.hash, e->idx.sha1);
} else { /* <sha1> */ } else { /* <sha1> */
if (get_sha1_hex(*p, sha1)) if (parse_oid_hex(*p, &oid, p))
die("Invalid dataref: %s", command_buf.buf); die("Invalid dataref: %s", command_buf.buf);
e = find_object(sha1); e = find_object(&oid);
*p += 40;
if (*(*p)++ != ' ') if (*(*p)++ != ' ')
die("Missing space after tree-ish: %s", command_buf.buf); die("Missing space after tree-ish: %s", command_buf.buf);
} }


while (!e || e->type != OBJ_TREE) while (!e || e->type != OBJ_TREE)
e = dereference(e, sha1); e = dereference(e, &oid);
return e; return e;
} }