len--;
if (args->verbose)
fprintf(stderr, "%.*s\n", (int)len, args->base);
- err = write_entry(args, args->tree->object.sha1, args->base,
+ err = write_entry(args, get_object_hash(args->tree->object), args->base,
len, 040777);
if (err)
return err;
commit = lookup_commit_reference_gently(oid.hash, 1);
if (commit) {
- commit_sha1 = commit->object.sha1;
+ commit_sha1 = get_object_hash(commit->object);
archive_time = commit->date;
} else {
commit_sha1 = NULL;
unsigned int mode;
int err;
- err = get_tree_entry(tree->object.sha1, prefix,
+ err = get_tree_entry(get_object_hash(tree->object), prefix,
tree_oid.hash, &mode);
if (err || !S_ISDIR(mode))
die("current working directory is untracked");
struct commit_list *next = list->next;
list->next = NULL;
if (0 <= sha1_array_lookup(&skipped_revs,
- list->item->object.sha1)) {
+ get_object_hash(list->item->object))) {
if (skipped_first && !*skipped_first)
*skipped_first = 1;
/* Move current to tried list */
result = get_merge_bases_many(rev[0], rev_nr - 1, rev + 1);
for (; result; result = result->next) {
- const unsigned char *mb = result->item->object.sha1;
+ const unsigned char *mb = get_object_hash(result->item->object);
if (!hashcmp(mb, current_bad_oid->hash)) {
handle_bad_merge_base();
} else if (0 <= sha1_array_lookup(&good_revs, mb)) {
exit(4);
}
- bisect_rev = revs.commits->item->object.sha1;
+ bisect_rev = get_object_hash(revs.commits->item->object);
if (!hashcmp(bisect_rev, current_bad_oid->hash)) {
exit_if_skipped_commits(tried, current_bad_oid);
if ((commit = lookup_commit_reference(sha1)) == NULL)
die(_("Not a valid branch point: '%s'."), start_name);
- hashcpy(sha1, commit->object.sha1);
+ hashcpy(sha1, get_object_hash(commit->object));
if (forcing)
snprintf(msg, sizeof msg, "branch: Reset to %s",
{
if (!is_null_sha1(origin->blob_sha1))
return 0;
- if (get_tree_entry(origin->commit->object.sha1,
+ if (get_tree_entry(get_object_hash(origin->commit->object),
origin->path,
origin->blob_sha1, &origin->mode))
goto error_out;
diff_setup_done(&diff_opts);
if (is_null_sha1(origin->commit->object.sha1))
- do_diff_cache(parent->tree->object.sha1, &diff_opts);
+ do_diff_cache(get_object_hash(parent->tree->object), &diff_opts);
else
- diff_tree_sha1(parent->tree->object.sha1,
- origin->commit->tree->object.sha1,
+ diff_tree_sha1(get_object_hash(parent->tree->object),
+ get_object_hash(origin->commit->tree->object),
"", &diff_opts);
diffcore_std(&diff_opts);
diff_setup_done(&diff_opts);
if (is_null_sha1(origin->commit->object.sha1))
- do_diff_cache(parent->tree->object.sha1, &diff_opts);
+ do_diff_cache(get_object_hash(parent->tree->object), &diff_opts);
else
- diff_tree_sha1(parent->tree->object.sha1,
- origin->commit->tree->object.sha1,
+ diff_tree_sha1(get_object_hash(parent->tree->object),
+ get_object_hash(origin->commit->tree->object),
"", &diff_opts);
diffcore_std(&diff_opts);
DIFF_OPT_SET(&diff_opts, FIND_COPIES_HARDER);
if (is_null_sha1(target->commit->object.sha1))
- do_diff_cache(parent->tree->object.sha1, &diff_opts);
+ do_diff_cache(get_object_hash(parent->tree->object), &diff_opts);
else
- diff_tree_sha1(parent->tree->object.sha1,
- target->commit->tree->object.sha1,
+ diff_tree_sha1(get_object_hash(parent->tree->object),
+ get_object_hash(target->commit->tree->object),
"", &diff_opts);
if (!DIFF_OPT_TST(&diff_opts, FIND_COPIES_HARDER))
static int update_auto_abbrev(int auto_abbrev, struct origin *suspect)
{
- const char *uniq = find_unique_abbrev(suspect->commit->object.sha1,
+ const char *uniq = find_unique_abbrev(get_object_hash(suspect->commit->object),
auto_abbrev);
int len = strlen(uniq);
if (auto_abbrev < len)
struct commit_list *parents;
for (parents = work_tree->parents; parents; parents = parents->next) {
- const unsigned char *commit_sha1 = parents->item->object.sha1;
+ const unsigned char *commit_sha1 = get_object_hash(parents->item->object);
unsigned char blob_sha1[20];
unsigned mode;
fill_tracking_info(&stat, refname, filter->verbose > 1);
strbuf_addf(out, " %s %s%s",
- find_unique_abbrev(item->commit->object.sha1, filter->abbrev),
+ find_unique_abbrev(get_object_hash(item->commit->object), filter->abbrev),
stat.buf, sub);
strbuf_release(&stat);
strbuf_release(&subject);
if (!parse_commit(commit))
pp_commit_easy(CMIT_FMT_ONELINE, commit, &sb);
fprintf(stderr, "%s %s... %s\n", msg,
- find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
+ find_unique_abbrev(get_object_hash(commit->object), DEFAULT_ABBREV), sb.buf);
strbuf_release(&sb);
}
setup_standard_excludes(topts.dir);
}
tree = parse_tree_indirect(old->commit ?
- old->commit->object.sha1 :
+ get_object_hash(old->commit->object) :
EMPTY_TREE_SHA1_BIN);
init_tree_desc(&trees[0], tree->buffer, tree->size);
tree = parse_tree_indirect(new->commit->object.sha1);
if (!strcmp(new->name, "HEAD") && !new->path && !opts->force_detach) {
/* Nothing to do. */
} else if (opts->force_detach || !new->path) { /* No longer on any branch. */
- update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
+ update_ref(msg.buf, "HEAD", get_object_hash(new->commit->object), NULL,
REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
if (!opts->quiet) {
if (old->path && advice_detached_head)
{
strbuf_addstr(sb, " ");
strbuf_addstr(sb,
- find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
+ find_unique_abbrev(get_object_hash(commit->object), DEFAULT_ABBREV));
strbuf_addch(sb, ' ');
if (!parse_commit(commit))
pp_commit_easy(CMIT_FMT_ONELINE, commit, sb);
" git branch <new-branch-name> %s\n\n",
/* Give ngettext() the count */
lost),
- find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
+ find_unique_abbrev(get_object_hash(commit->object), DEFAULT_ABBREV));
}
/*
} else if (our) {
struct commit *c = lookup_commit_reference(our->old_oid.hash);
/* --branch specifies a non-branch (i.e. tags), detach HEAD */
- update_ref(msg, "HEAD", c->object.sha1,
+ update_ref(msg, "HEAD", get_object_hash(c->object),
NULL, REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
} else if (remote) {
/*
opts.dst_index = &the_index;
opts.fn = oneway_merge;
- tree = parse_tree_indirect(current_head->object.sha1);
+ tree = parse_tree_indirect(get_object_hash(current_head->object));
if (!tree)
die(_("failed to unpack HEAD tree object"));
parse_tree(tree);
if (!transaction ||
ref_transaction_update(transaction, "HEAD", sha1,
current_head
- ? current_head->object.sha1 : null_sha1,
+ ? get_object_hash(current_head->object) : null_sha1,
0, sb.buf, &err) ||
ref_transaction_commit(transaction, &err)) {
rollback_index_files();
cfg = init_copy_notes_for_rewrite("amend");
if (cfg) {
/* we are amending, so current_head is not NULL */
- copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
+ copy_note_for_rewrite(cfg, get_object_hash(current_head->object), sha1);
finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
}
- run_rewrite_hook(current_head->object.sha1, sha1);
+ run_rewrite_hook(get_object_hash(current_head->object), sha1);
}
if (!quiet)
print_summary(prefix, sha1, !current_head);
if (!cmit)
die(_("%s is not a valid '%s' object"), arg, commit_type);
- n = find_commit_name(cmit->object.sha1);
+ n = find_commit_name(get_object_hash(cmit->object));
if (n && (tags || all || n->prio == 2)) {
/*
* Exact match to an existing ref.
*/
display_name(n);
if (longformat)
- show_suffix(0, n->tag ? n->tag->tagged->sha1 : sha1);
+ show_suffix(0, n->tag ? get_object_hash(*n->tag->tagged) : sha1);
if (dirty)
printf("%s", dirty);
printf("\n");
display_name(all_matches[0].name);
if (abbrev)
- show_suffix(all_matches[0].depth, cmit->object.sha1);
+ show_suffix(all_matches[0].depth, get_object_hash(cmit->object));
if (dirty)
printf("%s", dirty);
printf("\n");
return -1;
printf("%s %s\n", sha1_to_hex(tree1->object.sha1),
sha1_to_hex(tree2->object.sha1));
- diff_tree_sha1(tree1->object.sha1, tree2->object.sha1,
+ diff_tree_sha1(get_object_hash(tree1->object), get_object_hash(tree2->object),
"", &log_tree_opt.diffopt);
log_tree_diff_flush(&log_tree_opt);
return 0;
break;
case 1:
tree1 = opt->pending.objects[0].item;
- diff_tree_commit_sha1(tree1->sha1);
+ diff_tree_commit_sha1(get_object_hash(*tree1));
break;
case 2:
tree1 = opt->pending.objects[0].item;
tree2 = tree1;
tree1 = tmp;
}
- diff_tree_sha1(tree1->sha1,
- tree2->sha1,
+ diff_tree_sha1(get_object_hash(*tree1),
+ get_object_hash(*tree2),
"", &opt->diffopt);
log_tree_diff_flush(opt);
break;
*/
if (ent1->item->flags & UNINTERESTING)
swap = 1;
- sha1[swap] = ent0->item->sha1;
- sha1[1 - swap] = ent1->item->sha1;
+ sha1[swap] = get_object_hash(*ent0->item);
+ sha1[1 - swap] = get_object_hash(*ent1->item);
diff_tree_sha1(sha1[0], sha1[1], "", &revs->diffopt);
log_tree_diff_flush(revs);
return 0;
if (!revs->dense_combined_merges && !revs->combine_merges)
revs->dense_combined_merges = revs->combine_merges = 1;
for (i = 1; i < ents; i++)
- sha1_array_append(&parents, ent[i].item->sha1);
- diff_tree_combined(ent[0].item->sha1, &parents,
+ sha1_array_append(&parents, get_object_hash(*ent[i].item));
+ diff_tree_combined(get_object_hash(*ent[0].item), &parents,
revs->dense_combined_merges, revs);
sha1_array_clear(&parents);
return 0;
const char *name = entry->name;
int flags = (obj->flags & UNINTERESTING);
if (!obj->parsed)
- obj = parse_object(obj->sha1);
+ obj = parse_object(get_object_hash(*obj));
obj = deref_tag(obj, NULL, 0);
if (!obj)
die(_("invalid object '%s' given."), name);
} else if (obj->type == OBJ_BLOB) {
if (2 <= blobs)
die(_("more than two blobs given: '%s'"), name);
- hashcpy(blob[blobs].sha1, obj->sha1);
+ hashcpy(blob[blobs].sha1, get_object_hash(*obj));
blob[blobs].name = name;
blob[blobs].mode = entry->mode;
blobs++;
get_object_mark(&commit->parents->item->object) != 0 &&
!full_tree) {
parse_commit_or_die(commit->parents->item);
- diff_tree_sha1(commit->parents->item->tree->object.sha1,
- commit->tree->object.sha1, "", &rev->diffopt);
+ diff_tree_sha1(get_object_hash(commit->parents->item->tree->object),
+ get_object_hash(commit->tree->object), "", &rev->diffopt);
}
else
- diff_root_tree_sha1(commit->tree->object.sha1,
+ diff_root_tree_sha1(get_object_hash(commit->tree->object),
"", &rev->diffopt);
/* Export the referenced blobs, and remember the marks. */
return;
}
- buf = read_sha1_file(tag->object.sha1, &type, &size);
+ buf = read_sha1_file(get_object_hash(tag->object), &type, &size);
if (!buf)
die ("Could not read tag %s", sha1_to_hex(tag->object.sha1));
message = memmem(buf, size, "\n\n", 2);
/* handle nested tags */
while (tag && tag->object.type == OBJ_TAG) {
- parse_object(tag->object.sha1);
+ parse_object(get_object_hash(tag->object));
string_list_append(&extra_refs, full_name)->util = tag;
tag = (struct tag *)tag->tagged;
}
case OBJ_COMMIT:
break;
case OBJ_BLOB:
- export_blob(commit->object.sha1);
+ export_blob(get_object_hash(commit->object));
continue;
default: /* OBJ_TAG (nested tags) is already handled */
warning("Tag points to object of unexpected type %s, skipping.",
if (in_merge_bases(current, updated)) {
struct strbuf quickref = STRBUF_INIT;
int r;
- strbuf_add_unique_abbrev(&quickref, current->object.sha1, DEFAULT_ABBREV);
+ strbuf_add_unique_abbrev(&quickref, get_object_hash(current->object), DEFAULT_ABBREV);
strbuf_addstr(&quickref, "..");
strbuf_add_unique_abbrev(&quickref, ref->new_oid.hash, DEFAULT_ABBREV);
if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
} else if (force || ref->force) {
struct strbuf quickref = STRBUF_INIT;
int r;
- strbuf_add_unique_abbrev(&quickref, current->object.sha1, DEFAULT_ABBREV);
+ strbuf_add_unique_abbrev(&quickref, get_object_hash(current->object), DEFAULT_ABBREV);
strbuf_addstr(&quickref, "...");
strbuf_add_unique_abbrev(&quickref, ref->new_oid.hash, DEFAULT_ABBREV);
if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
if (!parent)
continue;
commit_list_insert(parent, &parents);
- add_merge_parent(result, obj->sha1, parent->object.sha1);
+ add_merge_parent(result, get_object_hash(*obj), get_object_hash(parent->object));
}
head_commit = lookup_commit(head);
if (head_commit)
while (parents) {
struct commit *cmit = pop_commit(&parents);
for (i = 0; i < result->nr; i++)
- if (!hashcmp(result->item[i].commit, cmit->object.sha1))
+ if (!hashcmp(result->item[i].commit, get_object_hash(cmit->object)))
result->item[i].used = 1;
}
* do a full fsck
*/
if (!(obj->flags & HAS_OBJ)) {
- if (has_sha1_pack(obj->sha1))
+ if (has_sha1_pack(get_object_hash(*obj)))
return; /* it is in pack - forget about it */
if (connectivity_only && has_sha1_file(obj->sha1))
return;
if (!(f = fopen(filename, "w")))
die_errno("Could not open '%s'", filename);
if (obj->type == OBJ_BLOB) {
- if (stream_blob_to_fd(fileno(f), obj->sha1, NULL, 1))
+ if (stream_blob_to_fd(fileno(f), get_object_hash(*obj), NULL, 1))
die_errno("Could not write '%s'", filename);
} else
fprintf(f, "%s\n", sha1_to_hex(obj->sha1));
struct object *obj, const char *name, const char *path)
{
if (obj->type == OBJ_BLOB)
- return grep_sha1(opt, obj->sha1, name, 0, path);
+ return grep_sha1(opt, get_object_hash(*obj), name, 0, path);
if (obj->type == OBJ_COMMIT || obj->type == OBJ_TREE) {
struct tree_desc tree;
void *data;
if (!(obj->flags & FLAG_CHECKED)) {
unsigned long size;
- int type = sha1_object_info(obj->sha1, &size);
+ int type = sha1_object_info(get_object_hash(*obj), &size);
if (type <= 0)
die(_("did not receive expected object %s"),
sha1_to_hex(obj->sha1));
const char *name = objects[i].name;
switch (o->type) {
case OBJ_BLOB:
- ret = show_blob_object(o->sha1, &rev, name);
+ ret = show_blob_object(get_object_hash(*o), &rev, name);
break;
case OBJ_TAG: {
struct tag *t = (struct tag *)o;
diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
t->tag,
diff_get_color_opt(&rev.diffopt, DIFF_RESET));
- ret = show_tag_object(o->sha1, &rev);
+ ret = show_tag_object(get_object_hash(*o), &rev);
rev.shown_one = 1;
if (ret)
break;
- o = parse_object(t->tagged->sha1);
+ o = parse_object(get_object_hash(*t->tagged));
if (!o)
ret = error(_("Could not read object %s"),
sha1_to_hex(t->tagged->sha1));
o2 = rev->pending.objects[1].item;
flags1 = o1->flags;
flags2 = o2->flags;
- c1 = lookup_commit_reference(o1->sha1);
- c2 = lookup_commit_reference(o2->sha1);
+ c1 = lookup_commit_reference(get_object_hash(*o1));
+ c2 = lookup_commit_reference(get_object_hash(*o2));
if ((flags1 & UNINTERESTING) == (flags2 & UNINTERESTING))
die(_("Not a range."));
diff_setup_done(&opts);
- diff_tree_sha1(origin->tree->object.sha1,
- head->tree->object.sha1,
+ diff_tree_sha1(get_object_hash(origin->tree->object),
+ get_object_hash(head->tree->object),
"", &opts);
diffcore_std(&opts);
diff_flush(&opts);
{
if (!verbose) {
printf("%c %s\n", sign,
- find_unique_abbrev(commit->object.sha1, abbrev));
+ find_unique_abbrev(get_object_hash(commit->object), abbrev));
} else {
struct strbuf buf = STRBUF_INIT;
pp_commit_easy(CMIT_FMT_ONELINE, commit, &buf);
printf("%c %s %s\n", sign,
- find_unique_abbrev(commit->object.sha1, abbrev),
+ find_unique_abbrev(get_object_hash(commit->object), abbrev),
buf.buf);
strbuf_release(&buf);
}
const char *path = entry->path;
if (!entry->stage)
- return read_sha1_file(entry->blob->object.sha1, &type, size);
+ return read_sha1_file(get_object_hash(entry->blob->object), &type, size);
base = NULL;
if (entry->stage == 1) {
base = entry->blob;
enum object_type type;
while (entry) {
if (entry->stage == 2)
- return read_sha1_file(entry->blob->object.sha1, &type, size);
+ return read_sha1_file(get_object_hash(entry->blob->object), &type, size);
entry = entry->link;
}
return NULL;
while ((commit = get_revision(&rev)) != NULL) {
strbuf_addch(&out, '\n');
strbuf_addf(&out, "commit %s\n",
- sha1_to_hex(commit->object.sha1));
+ sha1_to_hex(get_object_hash(commit->object)));
pretty_print_commit(&ctx, commit, &out);
}
if (write_in_full(fd, out.buf, out.len) != out.len)
const unsigned char *new_head, const char *msg)
{
struct strbuf reflog_message = STRBUF_INIT;
- const unsigned char *head = head_commit->object.sha1;
+ const unsigned char *head = get_object_hash(head_commit->object);
if (!msg)
strbuf_addstr(&reflog_message, getenv("GIT_REFLOG_ACTION"));
if (ref_exists(truname.buf)) {
strbuf_addf(msg,
"%s\t\tbranch '%s'%s of .\n",
- sha1_to_hex(remote_head->object.sha1),
+ sha1_to_hex(get_object_hash(remote_head->object)),
truname.buf + 11,
(early ? " (early part)" : ""));
strbuf_release(&truname);
desc = merge_remote_util(remote_head);
if (desc && desc->obj && desc->obj->type == OBJ_TAG) {
strbuf_addf(msg, "%s\t\t%s '%s'\n",
- sha1_to_hex(desc->obj->sha1),
+ sha1_to_hex(get_object_hash(*desc->obj)),
typename(desc->obj->type),
remote);
goto cleanup;
}
strbuf_addf(msg, "%s\t\tcommit '%s'\n",
- sha1_to_hex(remote_head->object.sha1), remote);
+ sha1_to_hex(get_object_hash(remote_head->object)), remote);
cleanup:
strbuf_release(&buf);
strbuf_release(&bname);
second_token = lookup_commit_reference_gently(second_sha1, 0);
if (!second_token)
die(_("'%s' is not a commit"), argv[1]);
- if (hashcmp(second_token->object.sha1, head))
+ if (hashcmp(get_object_hash(second_token->object), head))
return NULL;
}
return second_token;
if (c->util && merge_remote_util(c)->obj) {
sha1 = merge_remote_util(c)->obj->sha1;
} else {
- sha1 = c->object.sha1;
+ sha1 = get_object_hash(c->object);
}
strbuf_addf(&buf, "%s\n", sha1_to_hex(sha1));
}
die(_("%s - not something we can merge"), argv[0]);
if (remoteheads->next)
die(_("Can merge only exactly one commit into empty head"));
- read_empty(remote_head->object.sha1, 0);
- update_ref("initial pull", "HEAD", remote_head->object.sha1,
+ read_empty(get_object_hash(remote_head->object), 0);
+ update_ref("initial pull", "HEAD", get_object_hash(remote_head->object),
NULL, 0, UPDATE_REFS_DIE_ON_ERR);
goto done;
}
* additional safety measure to check for it.
*/
if (!have_message &&
- is_old_style_invocation(argc, argv, head_commit->object.sha1)) {
+ is_old_style_invocation(argc, argv, get_object_hash(head_commit->object))) {
warning("old-style 'git merge <msg> HEAD <commit>' is deprecated.");
strbuf_addstr(&merge_msg, argv[0]);
head_arg = argv[1];
check_commit_signature(commit, &signature_check);
- find_unique_abbrev_r(hex, commit->object.sha1, DEFAULT_ABBREV);
+ find_unique_abbrev_r(hex, get_object_hash(commit->object), DEFAULT_ABBREV);
switch (signature_check.result) {
case 'G':
break;
for (p = remoteheads; p; p = p->next) {
struct commit *commit = p->item;
strbuf_addf(&buf, "GITHEAD_%s",
- sha1_to_hex(commit->object.sha1));
+ sha1_to_hex(get_object_hash(commit->object)));
setenv(buf.buf, merge_remote_util(commit)->name, 1);
strbuf_reset(&buf);
if (fast_forward != FF_ONLY &&
free(list);
}
- update_ref("updating ORIG_HEAD", "ORIG_HEAD", head_commit->object.sha1,
+ update_ref("updating ORIG_HEAD", "ORIG_HEAD", get_object_hash(head_commit->object),
NULL, 0, UPDATE_REFS_DIE_ON_ERR);
if (remoteheads && !common)
goto done;
} else if (fast_forward != FF_NO && !remoteheads->next &&
!common->next &&
- !hashcmp(common->item->object.sha1, head_commit->object.sha1)) {
+ !hashcmp(get_object_hash(common->item->object), get_object_hash(head_commit->object))) {
/* Again the most common case of merging one remote. */
struct strbuf msg = STRBUF_INIT;
struct commit *commit;
if (verbosity >= 0) {
char from[GIT_SHA1_HEXSZ + 1], to[GIT_SHA1_HEXSZ + 1];
- find_unique_abbrev_r(from, head_commit->object.sha1,
+ find_unique_abbrev_r(from, get_object_hash(head_commit->object),
DEFAULT_ABBREV);
- find_unique_abbrev_r(to, remoteheads->item->object.sha1,
+ find_unique_abbrev_r(to, get_object_hash(remoteheads->item->object),
DEFAULT_ABBREV);
printf(_("Updating %s..%s\n"), from, to);
}
goto done;
}
- if (checkout_fast_forward(head_commit->object.sha1,
- commit->object.sha1,
+ if (checkout_fast_forward(get_object_hash(head_commit->object),
+ get_object_hash(commit->object),
overwrite_ignore)) {
ret = 1;
goto done;
}
- finish(head_commit, remoteheads, commit->object.sha1, msg.buf);
+ finish(head_commit, remoteheads, get_object_hash(commit->object), msg.buf);
drop_save();
goto done;
} else if (!remoteheads->next && common->next)
/* See if it is really trivial. */
git_committer_info(IDENT_STRICT);
printf(_("Trying really trivial in-index merge...\n"));
- if (!read_tree_trivial(common->item->object.sha1,
- head_commit->object.sha1,
- remoteheads->item->object.sha1)) {
+ if (!read_tree_trivial(get_object_hash(common->item->object),
+ get_object_hash(head_commit->object),
+ get_object_hash(remoteheads->item->object))) {
ret = merge_trivial(head_commit, remoteheads);
goto done;
}
* HEAD^^" would be missed.
*/
common_one = get_merge_bases(head_commit, j->item);
- if (hashcmp(common_one->item->object.sha1,
- j->item->object.sha1)) {
+ if (hashcmp(get_object_hash(common_one->item->object),
+ get_object_hash(j->item->object))) {
up_to_date = 0;
break;
}
int ret;
if (i) {
printf(_("Rewinding the tree to pristine...\n"));
- restore_state(head_commit->object.sha1, stash);
+ restore_state(get_object_hash(head_commit->object), stash);
}
if (use_strategies_nr != 1)
printf(_("Trying merge strategy %s...\n"),
* it up.
*/
if (!best_strategy) {
- restore_state(head_commit->object.sha1, stash);
+ restore_state(get_object_hash(head_commit->object), stash);
if (use_strategies_nr > 1)
fprintf(stderr,
_("No merge strategy handled the merge.\n"));
; /* We already have its result in the working tree. */
else {
printf(_("Rewinding the tree to pristine...\n"));
- restore_state(head_commit->object.sha1, stash);
+ restore_state(get_object_hash(head_commit->object), stash);
printf(_("Using the %s to prepare resolving by hand.\n"),
best_strategy);
try_merge_strategy(best_strategy, common, remoteheads,
struct tag *t = (struct tag *) o;
if (!t->tagged)
break; /* broken repository */
- o = parse_object(t->tagged->sha1);
+ o = parse_object(get_object_hash(*t->tagged));
deref = 1;
}
if (o && o->type == OBJ_COMMIT) {
tip_table.sorted = 1;
}
- found = sha1_pos(o->sha1, tip_table.table, tip_table.nr,
+ found = sha1_pos(get_object_hash(*o), tip_table.table, tip_table.nr,
nth_tip_table_ent);
if (0 <= found)
return tip_table.table[found].refname;
int always, int allow_undefined, int name_only)
{
const char *name;
- const unsigned char *sha1 = obj->sha1;
+ const unsigned char *sha1 = get_object_hash(*obj);
if (!name_only)
printf("%s ", caller_name ? caller_name : sha1_to_hex(sha1));
die("Could not parse commit from NOTES_MERGE_PARTIAL.");
if (partial->parents)
- hashcpy(parent_sha1, partial->parents->item->object.sha1);
+ hashcpy(parent_sha1, get_object_hash(partial->parents->item->object));
else
hashclr(parent_sha1);
static void show_commit(struct commit *commit, void *data)
{
- add_object_entry(commit->object.sha1, OBJ_COMMIT, NULL, 0);
+ add_object_entry(get_object_hash(commit->object), OBJ_COMMIT, NULL, 0);
commit->object.flags |= OBJECT_ADDED;
if (write_bitmap_index)
char *name = path_name(path, last);
add_preferred_base_object(name);
- add_object_entry(obj->sha1, obj->type, name, 0);
+ add_object_entry(get_object_hash(*obj), obj->type, name, 0);
obj->flags |= OBJECT_ADDED;
/*
static void show_edge(struct commit *commit)
{
- add_preferred_base(commit->object.sha1);
+ add_preferred_base(get_object_hash(commit->object));
}
struct in_pack_object {
static void mark_in_pack_object(struct object *object, struct packed_git *p, struct in_pack *in_pack)
{
- in_pack->array[in_pack->nr].offset = find_pack_entry_one(object->sha1, p);
+ in_pack->array[in_pack->nr].offset = find_pack_entry_one(get_object_hash(*object), p);
in_pack->array[in_pack->nr].object = object;
in_pack->nr++;
}
ofscmp);
for (i = 0; i < in_pack.nr; i++) {
struct object *o = in_pack.array[i].object;
- add_object_entry(o->sha1, o->type, "", 0);
+ add_object_entry(get_object_hash(*o), o->type, "", 0);
}
}
free(in_pack.array);
const char *last,
void *data)
{
- sha1_array_append(&recent_objects, obj->sha1);
+ sha1_array_append(&recent_objects, get_object_hash(*obj));
}
static void record_recent_commit(struct commit *commit, void *data)
{
- sha1_array_append(&recent_objects, commit->object.sha1);
+ sha1_array_append(&recent_objects, get_object_hash(commit->object));
}
static void get_object_list(int ac, const char **av)
struct commit_list *parent;
c = (struct commit *)study.objects[--study.nr].item;
- if (!c->object.parsed && !parse_object(c->object.sha1))
+ if (!c->object.parsed && !parse_object(get_object_hash(c->object)))
c->object.flags |= INCOMPLETE;
if (c->object.flags & INCOMPLETE) {
for (i = 0; i < found.nr; i++) {
struct commit *c =
(struct commit *)found.objects[i].item;
- if (!tree_is_complete(c->tree->object.sha1)) {
+ if (!tree_is_complete(get_object_hash(c->tree->object))) {
is_incomplete = 1;
c->object.flags |= INCOMPLETE;
}
const char *hex, *body;
const char *msg;
- hex = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV);
+ hex = find_unique_abbrev(get_object_hash(commit->object), DEFAULT_ABBREV);
printf(_("HEAD is now at %s"), hex);
msg = logmsg_reencode(commit, NULL, get_log_output_encoding());
body = strstr(msg, "\n\n");
if (!revs->graph)
fputs(get_revision_mark(revs, commit), stdout);
if (revs->abbrev_commit && revs->abbrev)
- fputs(find_unique_abbrev(commit->object.sha1, revs->abbrev),
+ fputs(find_unique_abbrev(get_object_hash(commit->object), revs->abbrev),
stdout);
else
fputs(sha1_to_hex(commit->object.sha1), stdout);
if (obj->type == OBJ_BLOB && !has_sha1_file(obj->sha1))
die("missing blob object '%s'", sha1_to_hex(obj->sha1));
if (info->revs->verify_objects && !obj->parsed && obj->type != OBJ_COMMIT)
- parse_object(obj->sha1);
+ parse_object(get_object_hash(*obj));
}
static void show_object(struct object *obj,
exclude = get_merge_bases(a, b);
while (exclude) {
struct commit *commit = pop_commit(&exclude);
- show_rev(REVERSED, commit->object.sha1, NULL);
+ show_rev(REVERSED, get_object_hash(commit->object), NULL);
}
}
*dotdot = '.';
commit = lookup_commit_reference(sha1);
for (parents = commit->parents; parents; parents = parents->next)
show_rev(parents_only ? NORMAL : REVERSED,
- parents->item->object.sha1, arg);
+ get_object_hash(parents->item->object), arg);
*dotdot = '^';
return 1;
}
else
printf("[%s] ",
- find_unique_abbrev(commit->object.sha1,
+ find_unique_abbrev(get_object_hash(commit->object),
DEFAULT_ABBREV));
}
puts(pretty_str);
head_len,
ref_name[i],
head_oid.hash,
- rev[i]->object.sha1);
+ get_object_hash(rev[i]->object));
if (extra < 0)
printf("%c [%s] ",
is_head ? '*' : ' ', ref_name[i]);
if (!(obj->flags & FLAG_OPEN)) {
unsigned long size;
- int type = sha1_object_info(obj->sha1, &size);
+ int type = sha1_object_info(get_object_hash(*obj), &size);
if (type != obj->type || type <= 0)
die("object of unexpected type");
obj->flags |= FLAG_WRITTEN;
if (revs->max_age == -1 && revs->min_age == -1)
goto out;
- buf = read_sha1_file(tag->sha1, &type, &size);
+ buf = read_sha1_file(get_object_hash(*tag), &type, &size);
if (!buf)
goto out;
line = memmem(buf, size, "\ntagger ", 8);
struct name_entry entry;
int cnt;
- hashcpy(it->sha1, tree->object.sha1);
+ hashcpy(it->sha1, get_object_hash(tree->object));
init_tree_desc(&desc, tree->buffer, tree->size);
cnt = 0;
while (tree_entry(&desc, &entry)) {
struct sha1_array parents = SHA1_ARRAY_INIT;
while (parent) {
- sha1_array_append(&parents, parent->item->object.sha1);
+ sha1_array_append(&parents, get_object_hash(parent->item->object));
parent = parent->next;
}
- diff_tree_combined(commit->object.sha1, &parents, dense, rev);
+ diff_tree_combined(get_object_hash(commit->object), &parents, dense, rev);
sha1_array_clear(&parents);
}
struct commit *c = lookup_commit_reference(sha1);
if (!c)
die(_("could not parse %s"), ref_name);
- if (hashcmp(sha1, c->object.sha1)) {
+ if (hashcmp(sha1, get_object_hash(c->object))) {
warning(_("%s %s is not a commit!"),
ref_name, sha1_to_hex(sha1));
}
if (!ret) {
enum object_type type;
unsigned long size;
- ret = read_sha1_file(commit->object.sha1, &type, &size);
+ ret = read_sha1_file(get_object_hash(commit->object), &type, &size);
if (!ret)
die("cannot read commit object %s",
sha1_to_hex(commit->object.sha1));
bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
pptr = &item->parents;
- graft = lookup_commit_graft(item->object.sha1);
+ graft = lookup_commit_graft(get_object_hash(item->object));
while (bufptr + parent_entry_len < tail && !memcmp(bufptr, "parent ", 7)) {
struct commit *new_parent;
return -1;
if (item->object.parsed)
return 0;
- buffer = read_sha1_file(item->object.sha1, &type, &size);
+ buffer = read_sha1_file(get_object_hash(item->object), &type, &size);
if (!buffer)
return quiet_on_missing ? -1 :
error("Could not read %s",
for (i = 0; i < a->nr; i++) {
object = a->objects[i].item;
- commit = lookup_commit_reference_gently(object->sha1, 1);
+ commit = lookup_commit_reference_gently(get_object_hash(*object), 1);
if (commit)
clear_commit_marks(commit, mark);
}
desc = merge_remote_util(parent);
if (!desc || !desc->obj)
return;
- buf = read_sha1_file(desc->obj->sha1, &type, &size);
+ buf = read_sha1_file(get_object_hash(*desc->obj), &type, &size);
if (!buf || type != OBJ_TAG)
goto free_return;
len = parse_signature(buf, size);
static unsigned int hash_obj(const struct object *obj, unsigned int n)
{
- return sha1hash(obj->sha1) % n;
+ return sha1hash(get_object_hash(*obj)) % n;
}
static void *insert_decoration(struct decoration *n, const struct object *base, void *decoration)
struct object_array_entry *ent;
ent = revs->pending.objects;
- if (diff_cache(revs, ent->item->sha1, ent->name, cached))
+ if (diff_cache(revs, get_object_hash(*ent->item), ent->name, cached))
exit(128);
diff_set_mnemonic_prefix(&revs->diffopt, "c/", cached ? "i/" : "w/");
}
}
- return commit->object.sha1;
+ return get_object_hash(commit->object);
}
enum ack_type {
if (!t->tagged)
break; /* broken repository */
o->flags |= COMPLETE;
- o = parse_object(t->tagged->sha1);
+ o = parse_object(get_object_hash(*t->tagged));
}
if (o && o->type == OBJ_COMMIT) {
struct commit *commit = (struct commit *)o;
return 0;
if (options->skiplist && object &&
- sha1_array_lookup(options->skiplist, object->sha1) >= 0)
+ sha1_array_lookup(options->skiplist, get_object_hash(*object)) >= 0)
return 0;
if (msg_type == FSCK_FATAL)
buffer += 41;
parent_line_count++;
}
- graft = lookup_commit_graft(commit->object.sha1);
+ graft = lookup_commit_graft(get_object_hash(commit->object));
parent_count = commit_list_count(commit->parents);
if (graft) {
if (graft->nr_parent == -1 && !parent_count)
enum object_type type;
buffer = to_free =
- read_sha1_file(tag->object.sha1, &type, &size);
+ read_sha1_file(get_object_hash(tag->object), &type, &size);
if (!buffer)
return report(options, &tag->object,
FSCK_MSG_MISSING_TAG_OBJECT,
struct active_request_slot *slot;
struct http_object_request *obj_req;
- obj_req = new_http_object_request(repo->url, request->obj->sha1);
+ obj_req = new_http_object_request(repo->url, get_object_hash(*request->obj));
if (obj_req == NULL) {
request->state = ABORTED;
return;
struct transfer_request *check_request = request_queue_head;
struct http_pack_request *preq;
- target = find_sha1_pack(request->obj->sha1, repo->packs);
+ target = find_sha1_pack(get_object_hash(*request->obj), repo->packs);
if (!target) {
fprintf(stderr, "Unable to fetch %s, will not be able to update server info refs\n", sha1_to_hex(request->obj->sha1));
repo->can_update_info_refs = 0;
ssize_t size;
git_zstream stream;
- unpacked = read_sha1_file(request->obj->sha1, &type, &len);
+ unpacked = read_sha1_file(get_object_hash(*request->obj), &type, &len);
hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(type), len) + 1;
/* Set it up */
if (request->state == RUN_MKCOL) {
if (request->curl_result == CURLE_OK ||
request->http_code == 405) {
- remote_dir_exists[request->obj->sha1[0]] = 1;
+ remote_dir_exists[get_object_hash(*request->obj)[0]] = 1;
start_put(request);
} else {
fprintf(stderr, "MKCOL %s failed, aborting (%d/%ld)\n",
start_fetch_loose(request);
return 1;
} else if (pushing && request->state == NEED_PUSH) {
- if (remote_dir_exists[request->obj->sha1[0]] == 1) {
+ if (remote_dir_exists[get_object_hash(*request->obj)[0]] == 1) {
start_put(request);
} else {
start_mkcol(request);
* Don't fetch the object if it's known to exist locally
* or is already in the request queue
*/
- if (remote_dir_exists[obj->sha1[0]] == -1)
- get_remote_object_list(obj->sha1[0]);
+ if (remote_dir_exists[get_object_hash(*obj)[0]] == -1)
+ get_remote_object_list(get_object_hash(*obj)[0]);
if (obj->flags & (LOCAL | FETCHING))
return;
* Don't push the object if it's known to exist on the remote
* or is already in the request queue
*/
- if (remote_dir_exists[obj->sha1[0]] == -1)
- get_remote_object_list(obj->sha1[0]);
+ if (remote_dir_exists[get_object_hash(*obj)[0]] == -1)
+ get_remote_object_list(get_object_hash(*obj)[0]);
if (obj->flags & (REMOTE | PUSHING))
return 0;
- target = find_sha1_pack(obj->sha1, repo->packs);
+ target = find_sha1_pack(get_object_hash(*obj), repo->packs);
if (target) {
obj->flags |= REMOTE;
return 0;
unsigned mode;
unsigned char sha1[20];
- if (get_tree_entry(commit->object.sha1, spec->path,
+ if (get_tree_entry(get_object_hash(commit->object), spec->path,
sha1, &mode))
die("There is no path %s in the commit", spec->path);
fill_filespec(spec, sha1, 1, mode);
assert(commit);
DIFF_QUEUE_CLEAR(&diff_queued_diff);
- diff_tree_sha1(parent ? parent->tree->object.sha1 : NULL,
- commit->tree->object.sha1, "", opt);
+ diff_tree_sha1(parent ? get_object_hash(parent->tree->object) : NULL,
+ get_object_hash(commit->tree->object), "", opt);
if (opt->detect_rename) {
filter_diffs_for_paths(range, 1);
if (diff_might_be_rename())
if (!obj)
break;
if (!obj->parsed)
- parse_object(obj->sha1);
+ parse_object(get_object_hash(*obj));
add_name_decoration(DECORATION_REF_TAG, refname, obj);
}
return 0;
struct commit_list *p;
for (p = commit->parents; p ; p = p->next) {
struct commit *parent = p->item;
- printf(" %s", find_unique_abbrev(parent->object.sha1, abbrev));
+ printf(" %s", find_unique_abbrev(get_object_hash(parent->object), abbrev));
}
}
{
struct commit_list *p = lookup_decoration(&opt->children, &commit->object);
for ( ; p; p = p->next) {
- printf(" %s", find_unique_abbrev(p->item->object.sha1, abbrev));
+ printf(" %s", find_unique_abbrev(get_object_hash(p->item->object), abbrev));
}
}
const struct commit_list *parent;
for (nth = 0, parent = commit->parents; parent; parent = parent->next) {
- if (!hashcmp(parent->item->object.sha1, sha1))
+ if (!hashcmp(get_object_hash(parent->item->object), sha1))
return nth;
nth++;
}
commit->parents->next->item->object.sha1))
strbuf_addf(&verify_message,
"merged tag '%s'\n", tag->tag);
- else if ((nth = which_parent(tag->tagged->sha1, commit)) < 0)
+ else if ((nth = which_parent(get_object_hash(*tag->tagged), commit)) < 0)
strbuf_addf(&verify_message, "tag %s names a non-parent %s\n",
- tag->tag, tag->tagged->sha1);
+ tag->tag, get_object_hash(*tag->tagged));
else
strbuf_addf(&verify_message,
"parent #%d, tagged '%s'\n", nth + 1, tag->tag);
if (!opt->graph)
put_revision_mark(opt, commit);
- fputs(find_unique_abbrev(commit->object.sha1, abbrev_commit), stdout);
+ fputs(find_unique_abbrev(get_object_hash(commit->object), abbrev_commit), stdout);
if (opt->print_parents)
show_parents(commit, abbrev_commit);
if (opt->children.name)
if (!opt->graph)
put_revision_mark(opt, commit);
- fputs(find_unique_abbrev(commit->object.sha1, abbrev_commit),
+ fputs(find_unique_abbrev(get_object_hash(commit->object), abbrev_commit),
stdout);
if (opt->print_parents)
show_parents(commit, abbrev_commit);
show_children(opt, commit, abbrev_commit);
if (parent)
printf(" (from %s)",
- find_unique_abbrev(parent->object.sha1,
+ find_unique_abbrev(get_object_hash(parent->object),
abbrev_commit));
fputs(diff_get_color_opt(&opt->diffopt, DIFF_RESET), stdout);
show_decorations(opt, commit);
struct strbuf notebuf = STRBUF_INIT;
raw = (opt->commit_format == CMIT_FMT_USERFORMAT);
- format_display_notes(commit->object.sha1, ¬ebuf,
+ format_display_notes(get_object_hash(commit->object), ¬ebuf,
get_log_output_encoding(), raw);
ctx.notes_message = notebuf.len
? strbuf_detach(¬ebuf, NULL)
unsigned long size;
enum object_type type;
- buf = read_sha1_file(obj->object.sha1, &type, &size);
+ buf = read_sha1_file(get_object_hash(obj->object), &type, &size);
if (!buf)
return -1;
if (type != OBJ_BLOB) {
return NULL;
if (!our)
our = their;
- return read_sha1_file(our->object.sha1, &type, size);
+ return read_sha1_file(get_object_hash(our->object), &type, size);
}
if (fill_mmfile_blob(&f1, our) < 0)
unsigned char shifted[20];
if (!*subtree_shift) {
- shift_tree(one->object.sha1, two->object.sha1, shifted, 0);
+ shift_tree(get_object_hash(one->object), get_object_hash(two->object), shifted, 0);
} else {
- shift_tree_by(one->object.sha1, two->object.sha1, shifted,
+ shift_tree_by(get_object_hash(one->object), get_object_hash(two->object), shifted,
subtree_shift);
}
if (!hashcmp(two->object.sha1, shifted))
if (commit->util)
printf("virtual %s\n", merge_remote_util(commit)->name);
else {
- printf("%s ", find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
+ printf("%s ", find_unique_abbrev(get_object_hash(commit->object), DEFAULT_ABBREV));
if (parse_commit(commit) != 0)
printf(_("(bad commit)\n"));
else {
{
struct string_list_item *item;
struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
- get_tree_entry(o->object.sha1, path,
+ get_tree_entry(get_object_hash(o->object), path,
e->stages[1].sha, &e->stages[1].mode);
- get_tree_entry(a->object.sha1, path,
+ get_tree_entry(get_object_hash(a->object), path,
e->stages[2].sha, &e->stages[2].mode);
- get_tree_entry(b->object.sha1, path,
+ get_tree_entry(get_object_hash(b->object), path,
e->stages[3].sha, &e->stages[3].mode);
item = string_list_insert(entries, path);
item->util = e;
opts.show_rename_progress = o->show_rename_progress;
opts.output_format = DIFF_FORMAT_NO_OUTPUT;
diff_setup_done(&opts);
- diff_tree_sha1(o_tree->object.sha1, tree->object.sha1, "", &opts);
+ diff_tree_sha1(get_object_hash(o_tree->object), get_object_hash(tree->object), "", &opts);
diffcore_std(&opts);
if (opts.needed_rename_limit > o->needed_rename_limit)
o->needed_rename_limit = opts.needed_rename_limit;
common = shift_tree_object(head, common, o->subtree_shift);
}
- if (sha_eq(common->object.sha1, merge->object.sha1)) {
+ if (sha_eq(get_object_hash(common->object), get_object_hash(merge->object))) {
output(o, 0, _("Already up-to-date!"));
*result = head;
return 1;
if (o->verbosity >= 4)
printf("No merge base found; doing history-less merge\n");
} else if (!bases->next) {
- base_sha1 = bases->item->object.sha1;
- base_tree_sha1 = bases->item->tree->object.sha1;
+ base_sha1 = get_object_hash(bases->item->object);
+ base_tree_sha1 = get_object_hash(bases->item->tree->object);
if (o->verbosity >= 4)
printf("One merge base found (%.7s)\n",
sha1_to_hex(base_sha1));
} else {
/* TODO: How to handle multiple merge-bases? */
- base_sha1 = bases->item->object.sha1;
- base_tree_sha1 = bases->item->tree->object.sha1;
+ base_sha1 = get_object_hash(bases->item->object);
+ base_tree_sha1 = get_object_hash(bases->item->tree->object);
if (o->verbosity >= 3)
printf("Multiple merge bases found. Using the first "
"(%.7s)\n", sha1_to_hex(base_sha1));
sha1_to_hex(local->object.sha1),
sha1_to_hex(base_sha1));
- if (!hashcmp(remote->object.sha1, base_sha1)) {
+ if (!hashcmp(get_object_hash(remote->object), base_sha1)) {
/* Already merged; result == local commit */
if (o->verbosity >= 2)
printf("Already up-to-date!\n");
- hashcpy(result_sha1, local->object.sha1);
+ hashcpy(result_sha1, get_object_hash(local->object));
goto found_result;
}
- if (!hashcmp(local->object.sha1, base_sha1)) {
+ if (!hashcmp(get_object_hash(local->object), base_sha1)) {
/* Fast-forward; result == remote commit */
if (o->verbosity >= 2)
printf("Fast-forward\n");
- hashcpy(result_sha1, remote->object.sha1);
+ hashcpy(result_sha1, get_object_hash(remote->object));
goto found_result;
}
- result = merge_from_diffs(o, base_tree_sha1, local->tree->object.sha1,
- remote->tree->object.sha1, local_tree);
+ result = merge_from_diffs(o, base_tree_sha1, get_object_hash(local->tree->object),
+ get_object_hash(remote->tree->object), local_tree);
if (result != 0) { /* non-trivial merge (with or without conflicts) */
/* Commit (partial) result */
*/
static void insert_obj_hash(struct object *obj, struct object **hash, unsigned int size)
{
- unsigned int j = hash_obj(obj->sha1, size);
+ unsigned int j = hash_obj(get_object_hash(*obj), size);
while (hash[j]) {
j++;
first = i = hash_obj(sha1, obj_hash_size);
while ((obj = obj_hash[i]) != NULL) {
- if (!hashcmp(sha1, obj->sha1))
+ if (!hashcmp(sha1, get_object_hash(*obj)))
break;
i++;
if (i == obj_hash_size)
obj->parsed = 0;
obj->used = 0;
obj->flags = 0;
- hashcpy(obj->sha1, sha1);
+ hashcpy(get_object_hash(*obj), sha1);
if (obj_hash_size - 1 <= nr_objs * 2)
grow_object_hash();
const char *last, void *data)
{
struct bitmap *base = data;
- bitmap_set(base, find_object_pos(object->sha1));
+ bitmap_set(base, find_object_pos(get_object_hash(*object)));
mark_as_seen(object);
}
add_to_include_set(struct bitmap *base, struct commit *commit)
{
khiter_t hash_pos;
- uint32_t bitmap_pos = find_object_pos(commit->object.sha1);
+ uint32_t bitmap_pos = find_object_pos(get_object_hash(commit->object));
if (bitmap_get(base, bitmap_pos))
return 0;
- hash_pos = kh_get_sha1(writer.bitmaps, commit->object.sha1);
+ hash_pos = kh_get_sha1(writer.bitmaps, get_object_hash(commit->object));
if (hash_pos < kh_end(writer.bitmaps)) {
struct bitmapped_commit *bc = kh_value(writer.bitmaps, hash_pos);
bitmap_or_ewah(base, bc->bitmap);
if (i >= reuse_after)
stored->flags |= BITMAP_FLAG_REUSE;
- hash_pos = kh_put_sha1(writer.bitmaps, object->sha1, &hash_ret);
+ hash_pos = kh_put_sha1(writer.bitmaps, get_object_hash(*object), &hash_ret);
if (hash_ret == 0)
die("Duplicate entry when writing index: %s",
sha1_to_hex(object->sha1));
if (next == 0) {
chosen = indexed_commits[i];
- reused_bitmap = find_reused_bitmap(chosen->object.sha1);
+ reused_bitmap = find_reused_bitmap(get_object_hash(chosen->object));
} else {
chosen = indexed_commits[i + next];
for (j = 0; j <= next; ++j) {
struct commit *cm = indexed_commits[i + j];
- reused_bitmap = find_reused_bitmap(cm->object.sha1);
+ reused_bitmap = find_reused_bitmap(get_object_hash(cm->object));
if (reused_bitmap || (cm->object.flags & NEEDS_BITMAP) != 0) {
chosen = cm;
break;
struct bitmapped_commit *stored = &writer.selected[i];
int commit_pos =
- sha1_pos(stored->commit->object.sha1, index, index_nr, sha1_access);
+ sha1_pos(get_object_hash(stored->commit->object), index, index_nr, sha1_access);
if (commit_pos < 0)
die("BUG: trying to write commit not in index");
int hash_ret;
int bitmap_pos;
- hash_pos = kh_put_sha1_pos(eindex->positions, object->sha1, &hash_ret);
+ hash_pos = kh_put_sha1_pos(eindex->positions, get_object_hash(*object), &hash_ret);
if (hash_ret > 0) {
if (eindex->count >= eindex->alloc) {
eindex->alloc = (eindex->alloc + 16) * 3 / 2;
struct bitmap *base = data;
int bitmap_pos;
- bitmap_pos = bitmap_position(object->sha1);
+ bitmap_pos = bitmap_position(get_object_hash(*object));
if (bitmap_pos < 0) {
char *name = path_name(path, last);
struct include_data *data = _data;
int bitmap_pos;
- bitmap_pos = bitmap_position(commit->object.sha1);
+ bitmap_pos = bitmap_position(get_object_hash(commit->object));
if (bitmap_pos < 0)
bitmap_pos = ext_index_add_object((struct object *)commit, NULL);
- if (!add_to_include_set(data, commit->object.sha1, bitmap_pos)) {
+ if (!add_to_include_set(data, get_object_hash(commit->object), bitmap_pos)) {
struct commit_list *parent = commit->parents;
while (parent) {
roots = roots->next;
if (object->type == OBJ_COMMIT) {
- khiter_t pos = kh_get_sha1(bitmap_git.bitmaps, object->sha1);
+ khiter_t pos = kh_get_sha1(bitmap_git.bitmaps, get_object_hash(*object));
if (pos < kh_end(bitmap_git.bitmaps)) {
struct stored_bitmap *st = kh_value(bitmap_git.bitmaps, pos);
int pos;
roots = roots->next;
- pos = bitmap_position(object->sha1);
+ pos = bitmap_position(get_object_hash(*object));
if (pos < 0 || base == NULL || !bitmap_get(base, pos)) {
object->flags &= ~UNINTERESTING;
continue;
obj = eindex->objects[i];
- show_reach(obj->sha1, obj->type, 0, eindex->hashes[i], NULL, 0);
+ show_reach(get_object_hash(*obj), obj->type, 0, eindex->hashes[i], NULL, 0);
}
}
struct object *object = roots->item;
roots = roots->next;
- if (find_pack_entry_one(object->sha1, bitmap_git.pack) > 0)
+ if (find_pack_entry_one(get_object_hash(*object), bitmap_git.pack) > 0)
return 1;
}
struct object *object = pending_e[i].item;
if (object->type == OBJ_NONE)
- parse_object_or_die(object->sha1, NULL);
+ parse_object_or_die(get_object_hash(*object), NULL);
while (object->type == OBJ_TAG) {
struct tag *tag = (struct tag *) object;
if (!tag->tagged)
die("bad tag");
- object = parse_object_or_die(tag->tagged->sha1, NULL);
+ object = parse_object_or_die(get_object_hash(*tag->tagged), NULL);
}
if (object->flags & UNINTERESTING)
struct bitmap_test_data *tdata = data;
int bitmap_pos;
- bitmap_pos = bitmap_position(object->sha1);
+ bitmap_pos = bitmap_position(get_object_hash(*object));
if (bitmap_pos < 0)
die("Object not in bitmap: %s\n", sha1_to_hex(object->sha1));
struct bitmap_test_data *tdata = data;
int bitmap_pos;
- bitmap_pos = bitmap_position(commit->object.sha1);
+ bitmap_pos = bitmap_position(get_object_hash(commit->object));
if (bitmap_pos < 0)
die("Object not in bitmap: %s\n", sha1_to_hex(commit->object.sha1));
bitmap_git.version, bitmap_git.entry_count);
root = revs->pending.objects[0].item;
- pos = kh_get_sha1(bitmap_git.bitmaps, root->sha1);
+ pos = kh_get_sha1(bitmap_git.bitmaps, get_object_hash(*root));
if (pos < kh_end(bitmap_git.bitmaps)) {
struct stored_bitmap *st = kh_value(bitmap_git.bitmaps, pos);
unsigned char *sha1)
{
if (commit->parents)
- diff_tree_sha1(commit->parents->item->object.sha1,
- commit->object.sha1, "", options);
+ diff_tree_sha1(get_object_hash(commit->parents->item->object),
+ get_object_hash(commit->object), "", options);
else
- diff_root_tree_sha1(commit->object.sha1, "", options);
+ diff_root_tree_sha1(get_object_hash(commit->object), "", options);
diffcore_std(options);
return diff_flush_patch_id(options, sha1);
}
struct commit *p = parent->item;
const char *hex = NULL;
if (pp->abbrev)
- hex = find_unique_abbrev(p->object.sha1, pp->abbrev);
+ hex = find_unique_abbrev(get_object_hash(p->object), pp->abbrev);
if (!hex)
hex = sha1_to_hex(p->object.sha1);
parent = parent->next;
/* these depend on the commit */
if (!commit->object.parsed)
- parse_object(commit->object.sha1);
+ parse_object(get_object_hash(commit->object));
switch (placeholder[0]) {
case 'H': /* commit hash */
strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
return 1;
}
- strbuf_addstr(sb, find_unique_abbrev(commit->object.sha1,
+ strbuf_addstr(sb, find_unique_abbrev(get_object_hash(commit->object),
c->pretty_ctx->abbrev));
strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
c->abbrev_commit_hash.len = sb->len - c->abbrev_commit_hash.off;
if (p != commit->parents)
strbuf_addch(sb, ' ');
strbuf_addstr(sb, find_unique_abbrev(
- p->item->object.sha1,
+ get_object_hash(p->item->object),
c->pretty_ctx->abbrev));
}
c->abbrev_parent_hashes.len = sb->len -
v->s = xstrfmt("%lu", sz);
}
else if (deref)
- grab_objectname(name, obj->sha1, v);
+ grab_objectname(name, get_object_hash(*obj), v);
}
}
* If it is a tag object, see if we use a value that derefs
* the object, and if we do grab the object it refers to.
*/
- tagged = ((struct tag *)obj)->tagged->sha1;
+ tagged = get_object_hash(*((struct tag *)obj)->tagged);
/*
* NEEDSWORK: This derefs tag only once, which
if (!obj)
die(_("malformed object at '%s'"), refname);
if (obj->type == OBJ_TAG)
- tagged_sha1 = ((struct tag *)obj)->tagged->sha1;
+ tagged_sha1 = get_object_hash(*((struct tag *)obj)->tagged);
if (tagged_sha1 && sha1_array_lookup(points_at, tagged_sha1) >= 0)
return tagged_sha1;
return NULL;
if (!o)
return PEEL_INVALID;
- hashcpy(sha1, o->sha1);
+ hashcpy(sha1, get_object_hash(*o));
return PEEL_PEELED;
}
add_pending_object(revs, object, tag->tag);
if (!tag->tagged)
die("bad tag");
- object = parse_object(tag->tagged->sha1);
+ object = parse_object(get_object_hash(*tag->tagged));
if (!object) {
if (flags & UNINTERESTING)
return NULL;
tree_difference = REV_TREE_SAME;
DIFF_OPT_CLR(&revs->pruning, HAS_CHANGES);
- if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "",
+ if (diff_tree_sha1(get_object_hash(t1->object), get_object_hash(t2->object), "",
&revs->pruning) < 0)
return REV_TREE_DIFFERENT;
return tree_difference;
tree_difference = REV_TREE_SAME;
DIFF_OPT_CLR(&revs->pruning, HAS_CHANGES);
- retval = diff_tree_sha1(NULL, t1->object.sha1, "", &revs->pruning);
+ retval = diff_tree_sha1(NULL, get_object_hash(t1->object), "", &revs->pruning);
return retval >= 0 && (tree_difference == REV_TREE_SAME);
}
break;
if (!((struct tag*)it)->tagged)
return 0;
- hashcpy(sha1, ((struct tag*)it)->tagged->sha1);
+ hashcpy(sha1, get_object_hash(*((struct tag*)it)->tagged));
}
if (it->type != OBJ_COMMIT)
return 0;
a = (a_obj->type == OBJ_COMMIT
? (struct commit *)a_obj
- : lookup_commit_reference(a_obj->sha1));
+ : lookup_commit_reference(get_object_hash(*a_obj)));
b = (b_obj->type == OBJ_COMMIT
? (struct commit *)b_obj
- : lookup_commit_reference(b_obj->sha1));
+ : lookup_commit_reference(get_object_hash(*b_obj)));
if (!a || !b)
goto missing;
exclude = get_merge_bases(a, b);
if (opt->show_notes) {
if (!buf.len)
strbuf_addstr(&buf, message);
- format_display_notes(commit->object.sha1, &buf, encoding, 1);
+ format_display_notes(get_object_hash(commit->object), &buf, encoding, 1);
}
/*
{
if (commit->object.flags & SHOWN)
return commit_ignore;
- if (revs->unpacked && has_sha1_pack(commit->object.sha1))
+ if (revs->unpacked && has_sha1_pack(get_object_hash(commit->object)))
return commit_ignore;
if (revs->show_all)
return commit_show;
if (cache_tree_update(&the_index, 0))
return error(_("Unable to update cache tree\n"));
- return !hashcmp(active_cache_tree->sha1, head_commit->tree->object.sha1);
+ return !hashcmp(active_cache_tree->sha1, get_object_hash(head_commit->tree->object));
}
/*
if (parse_commit(parent))
return error(_("Could not parse parent commit %s\n"),
sha1_to_hex(parent->object.sha1));
- ptree_sha1 = parent->tree->object.sha1;
+ ptree_sha1 = get_object_hash(parent->tree->object);
} else {
ptree_sha1 = EMPTY_TREE_SHA1_BIN; /* commit is root */
}
- return !hashcmp(ptree_sha1, commit->tree->object.sha1);
+ return !hashcmp(ptree_sha1, get_object_hash(commit->tree->object));
}
/*
parent = commit->parents->item;
if (opts->allow_ff &&
- ((parent && !hashcmp(parent->object.sha1, head)) ||
+ ((parent && !hashcmp(get_object_hash(parent->object), head)) ||
(!parent && unborn)))
- return fast_forward_to(commit->object.sha1, head, unborn, opts);
+ return fast_forward_to(get_object_hash(commit->object), head, unborn, opts);
if (parent && parse_commit(parent) < 0)
/* TRANSLATORS: The first %s will be "revert" or
* write it at all.
*/
if (opts->action == REPLAY_PICK && !opts->no_commit && (res == 0 || res == 1))
- update_ref(NULL, "CHERRY_PICK_HEAD", commit->object.sha1, NULL,
+ update_ref(NULL, "CHERRY_PICK_HEAD", get_object_hash(commit->object), NULL,
REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
if (opts->action == REPLAY_REVERT && ((opts->no_commit && res == 0) || res == 1))
- update_ref(NULL, "REVERT_HEAD", commit->object.sha1, NULL,
+ update_ref(NULL, "REVERT_HEAD", get_object_hash(commit->object), NULL,
REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
if (res) {
error(opts->action == REPLAY_REVERT
? _("could not revert %s... %s")
: _("could not apply %s... %s"),
- find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV),
+ find_unique_abbrev(get_object_hash(commit->object), DEFAULT_ABBREV),
msg.subject);
print_advice(res == 1, opts);
rerere(opts->allow_rerere_auto);
for (cur = todo_list; cur; cur = cur->next) {
const char *commit_buffer = get_commit_buffer(cur->item, NULL);
- sha1_abbrev = find_unique_abbrev(cur->item->object.sha1, DEFAULT_ABBREV);
+ sha1_abbrev = find_unique_abbrev(get_object_hash(cur->item->object), DEFAULT_ABBREV);
subject_len = find_commit_subject(commit_buffer, &subject);
strbuf_addf(buf, "%s %s %.*s\n", action_str, sha1_abbrev,
subject_len, subject);
if (parse_commit(commit))
return -1;
if (!idx) {
- hashcpy(result, commit->object.sha1);
+ hashcpy(result, get_object_hash(commit->object));
return 0;
}
p = commit->parents;
while (p) {
if (!--idx) {
- hashcpy(result, p->item->object.sha1);
+ hashcpy(result, get_object_hash(p->item->object));
return 0;
}
p = p->next;
return -1;
commit = commit->parents->item;
}
- hashcpy(result, commit->object.sha1);
+ hashcpy(result, get_object_hash(commit->object));
return 0;
}
if (name && !namelen)
namelen = strlen(name);
while (1) {
- if (!o || (!o->parsed && !parse_object(o->sha1)))
+ if (!o || (!o->parsed && !parse_object(get_object_hash(*o))))
return NULL;
if (expected_type == OBJ_ANY || o->type == expected_type)
return o;
return -1;
if (!expected_type) {
o = deref_tag(o, name, sp - name - 2);
- if (!o || (!o->parsed && !parse_object(o->sha1)))
+ if (!o || (!o->parsed && !parse_object(get_object_hash(*o))))
return -1;
hashcpy(sha1, o->sha1);
return 0;
if (!o)
return -1;
- hashcpy(sha1, o->sha1);
+ hashcpy(sha1, get_object_hash(*o));
if (sp[0] == '/') {
/* "$commit^{/foo}" */
char *prefix;
int matches;
commit = pop_most_recent_commit(&list, ONELINE_SEEN);
- if (!parse_object(commit->object.sha1))
+ if (!parse_object(get_object_hash(commit->object)))
continue;
buf = get_commit_buffer(commit, NULL);
p = strstr(buf, "\n\n");
unuse_commit_buffer(commit, buf);
if (matches) {
- hashcpy(sha1, commit->object.sha1);
+ hashcpy(sha1, get_object_hash(commit->object));
found = 1;
break;
}
cur_depth++;
if ((depth != INFINITE_DEPTH && cur_depth >= depth) ||
(is_repository_shallow() && !commit->parents &&
- (graft = lookup_commit_graft(commit->object.sha1)) != NULL &&
+ (graft = lookup_commit_graft(get_object_hash(commit->object))) != NULL &&
graft->nr_parent < 0)) {
commit_list_insert(commit, &result);
commit->object.flags |= shallow_flag;
diff_opts.output_format |= DIFF_FORMAT_CALLBACK;
diff_opts.format_callback = submodule_collect_changed_cb;
diff_setup_done(&diff_opts);
- diff_tree_sha1(parent->item->object.sha1, commit->object.sha1, "", &diff_opts);
+ diff_tree_sha1(get_object_hash(parent->item->object), get_object_hash(commit->object), "", &diff_opts);
diffcore_std(&diff_opts);
diff_flush(&diff_opts);
parent = parent->next;
{
while (o && o->type == OBJ_TAG)
if (((struct tag *)o)->tagged)
- o = parse_object(((struct tag *)o)->tagged->sha1);
+ o = parse_object(get_object_hash(*((struct tag *)o)->tagged));
else
o = NULL;
if (!o && warn) {
struct object *deref_tag_noverify(struct object *o)
{
while (o && o->type == OBJ_TAG) {
- o = parse_object(o->sha1);
+ o = parse_object(get_object_hash(*o));
if (o && o->type == OBJ_TAG && ((struct tag *)o)->tagged)
o = ((struct tag *)o)->tagged;
else
if (item->object.parsed)
return 0;
- data = read_sha1_file(item->object.sha1, &type, &size);
+ data = read_sha1_file(get_object_hash(item->object), &type, &size);
if (!data)
return error("Could not read %s",
sha1_to_hex(item->object.sha1));
if (!two)
die("not a tree-ish %s", av[2]);
- shift_tree(one->object.sha1, two->object.sha1, shifted, -1);
+ shift_tree(get_object_hash(one->object), get_object_hash(two->object), shifted, -1);
printf("shifted: %s\n", sha1_to_hex(shifted));
exit(0);
sha1_to_hex(entry.sha1),
base->buf, entry.path);
- hashcpy(sha1, commit->tree->object.sha1);
+ hashcpy(sha1, get_object_hash(commit->tree->object));
}
else
continue;
if (item->object.parsed)
return 0;
- buffer = read_sha1_file(item->object.sha1, &type, &size);
+ buffer = read_sha1_file(get_object_hash(item->object), &type, &size);
if (!buffer)
return quiet_on_missing ? -1 :
error("Could not read %s",
break;
}
if (!commit->object.parsed)
- parse_object(commit->object.sha1);
+ parse_object(get_object_hash(commit->object));
if (commit->object.flags & REACHABLE)
continue;
commit->object.flags |= REACHABLE;
if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
packet_write(1, "shallow %s",
sha1_to_hex(object->sha1));
- register_shallow(object->sha1);
+ register_shallow(get_object_hash(*object));
shallow_nr++;
}
result = result->next;
sha1_to_hex(object->sha1));
object->flags &= ~CLIENT_SHALLOW;
/* make sure the real parents are parsed */
- unregister_shallow(object->sha1);
+ unregister_shallow(get_object_hash(*object));
object->parsed = 0;
parse_commit_or_die((struct commit *)object);
parents = ((struct commit *)object)->parents;
add_object_array(object, NULL, &extra_edge_obj);
}
/* make sure commit traversal conforms to client */
- register_shallow(object->sha1);
+ register_shallow(get_object_hash(*object));
}
packet_flush(1);
} else
if (shallows.nr > 0) {
int i;
for (i = 0; i < shallows.nr; i++)
- register_shallow(shallows.objects[i].item->sha1);
+ register_shallow(get_object_hash(*shallows.objects[i].item));
}
shallow_nr += shallows.nr;
if (commit->object.flags & COMPLETE)
return 0;
- hashcpy(current_commit_sha1, commit->object.sha1);
+ hashcpy(current_commit_sha1, get_object_hash(commit->object));
walker_say(walker, "walk %s\n", sha1_to_hex(commit->object.sha1));
else {
if (obj->flags & COMPLETE)
return 0;
- walker->prefetch(walker, obj->sha1);
+ walker->prefetch(walker, get_object_hash(*obj));
}
object_list_insert(obj, process_queue_end);
* the queue because we needed to fetch it first.
*/
if (! (obj->flags & TO_SCAN)) {
- if (walker->fetch(walker, obj->sha1)) {
+ if (walker->fetch(walker, get_object_hash(*obj))) {
report_missing(obj);
return -1;
}
}
if (!obj->type)
- parse_object(obj->sha1);
+ parse_object(get_object_hash(*obj));
if (process_object(walker, obj))
return -1;
}
(!hashcmp(cb.nsha1, sha1) ||
/* perhaps sha1 is a tag, try to dereference to a commit */
((commit = lookup_commit_reference_gently(sha1, 1)) != NULL &&
- !hashcmp(cb.nsha1, commit->object.sha1)))) {
+ !hashcmp(cb.nsha1, get_object_hash(commit->object))))) {
const char *from = ref;
if (!skip_prefix(from, "refs/tags/", &from))
skip_prefix(from, "refs/remotes/", &from);
projects / thirdparty / git.git / commitdiff
