зеркало из https://github.com/microsoft/git.git
Merge branch 'bc/object-id'
for_each_ref() callback functions were taught to name the objects not with "unsigned char sha1[20]" but with "struct object_id". * bc/object-id: (56 commits) struct ref_lock: convert old_sha1 member to object_id warn_if_dangling_symref(): convert local variable "junk" to object_id each_ref_fn_adapter(): remove adapter rev_list_insert_ref(): remove unneeded arguments rev_list_insert_ref_oid(): new function, taking an object_oid mark_complete(): remove unneeded arguments mark_complete_oid(): new function, taking an object_oid clear_marks(): rewrite to take an object_id argument mark_complete(): rewrite to take an object_id argument send_ref(): convert local variable "peeled" to object_id upload-pack: rewrite functions to take object_id arguments find_symref(): convert local variable "unused" to object_id find_symref(): rewrite to take an object_id argument write_one_ref(): rewrite to take an object_id argument write_refs_to_temp_dir(): convert local variable sha1 to object_id submodule: rewrite to take an object_id argument shallow: rewrite functions to take object_id arguments handle_one_ref(): rewrite to take an object_id argument add_info_ref(): rewrite to take an object_id argument handle_one_reflog(): rewrite to take an object_id argument ...
This commit is contained in:
Junio C Hamano
Коммит
5455ee0573
|
|
@ -6,7 +6,7 @@ Iteration of refs is done by using an iterate function which will call a
|
|||
callback function for every ref. The callback function has this
|
||||
signature:
|
||||
|
||||
int handle_one_ref(const char *refname, const unsigned char *sha1,
|
||||
int handle_one_ref(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data);
|
||||
|
||||
There are different kinds of iterate functions which all take a
|
||||
|
|
|
|||
8
bisect.c
8
bisect.c
|
|
@ -400,16 +400,16 @@ struct commit_list *find_bisection(struct commit_list *list,
|
|||
return best;
|
||||
}
|
||||
|
||||
static int register_ref(const char *refname, const unsigned char *sha1,
|
||||
static int register_ref(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
if (!strcmp(refname, "bad")) {
|
||||
current_bad_oid = xmalloc(sizeof(*current_bad_oid));
|
||||
hashcpy(current_bad_oid->hash, sha1);
|
||||
oidcpy(current_bad_oid, oid);
|
||||
} else if (starts_with(refname, "good-")) {
|
||||
sha1_array_append(&good_revs, sha1);
|
||||
sha1_array_append(&good_revs, oid->hash);
|
||||
} else if (starts_with(refname, "skip-")) {
|
||||
sha1_array_append(&skipped_revs, sha1);
|
||||
sha1_array_append(&skipped_revs, oid->hash);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -326,7 +326,7 @@ static int match_patterns(const char **pattern, const char *refname)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int append_ref(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
|
||||
static int append_ref(const char *refname, const struct object_id *oid, int flags, void *cb_data)
|
||||
{
|
||||
struct append_ref_cb *cb = (struct append_ref_cb *)(cb_data);
|
||||
struct ref_list *ref_list = cb->ref_list;
|
||||
|
|
@ -363,7 +363,7 @@ static int append_ref(const char *refname, const unsigned char *sha1, int flags,
|
|||
|
||||
commit = NULL;
|
||||
if (ref_list->verbose || ref_list->with_commit || merge_filter != NO_FILTER) {
|
||||
commit = lookup_commit_reference_gently(sha1, 1);
|
||||
commit = lookup_commit_reference_gently(oid->hash, 1);
|
||||
if (!commit) {
|
||||
cb->ret = error(_("branch '%s' does not point at a commit"), refname);
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -702,10 +702,10 @@ static void update_refs_for_switch(const struct checkout_opts *opts,
|
|||
}
|
||||
|
||||
static int add_pending_uninteresting_ref(const char *refname,
|
||||
const unsigned char *sha1,
|
||||
const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
add_pending_sha1(cb_data, refname, sha1, UNINTERESTING);
|
||||
add_pending_sha1(cb_data, refname, oid->hash, UNINTERESTING);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -119,10 +119,10 @@ static void add_to_known_names(const char *path,
|
|||
}
|
||||
}
|
||||
|
||||
static int get_name(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int get_name(const char *path, const struct object_id *oid, int flag, void *cb_data)
|
||||
{
|
||||
int is_tag = starts_with(path, "refs/tags/");
|
||||
unsigned char peeled[20];
|
||||
struct object_id peeled;
|
||||
int is_annotated, prio;
|
||||
|
||||
/* Reject anything outside refs/tags/ unless --all */
|
||||
|
|
@ -134,10 +134,10 @@ static int get_name(const char *path, const unsigned char *sha1, int flag, void
|
|||
return 0;
|
||||
|
||||
/* Is it annotated? */
|
||||
if (!peel_ref(path, peeled)) {
|
||||
is_annotated = !!hashcmp(sha1, peeled);
|
||||
if (!peel_ref(path, peeled.hash)) {
|
||||
is_annotated = !!oidcmp(oid, &peeled);
|
||||
} else {
|
||||
hashcpy(peeled, sha1);
|
||||
oidcpy(&peeled, oid);
|
||||
is_annotated = 0;
|
||||
}
|
||||
|
||||
|
|
@ -154,7 +154,7 @@ static int get_name(const char *path, const unsigned char *sha1, int flag, void
|
|||
else
|
||||
prio = 0;
|
||||
|
||||
add_to_known_names(all ? path + 5 : path + 10, peeled, prio, sha1);
|
||||
add_to_known_names(all ? path + 5 : path + 10, peeled.hash, prio, oid->hash);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -179,13 +179,15 @@ static void add_merge_config(struct ref **head,
|
|||
}
|
||||
}
|
||||
|
||||
static int add_existing(const char *refname, const unsigned char *sha1,
|
||||
static int add_existing(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cbdata)
|
||||
{
|
||||
struct string_list *list = (struct string_list *)cbdata;
|
||||
struct string_list_item *item = string_list_insert(list, refname);
|
||||
item->util = xmalloc(20);
|
||||
hashcpy(item->util, sha1);
|
||||
struct object_id *old_oid = xmalloc(sizeof(*old_oid));
|
||||
|
||||
oidcpy(old_oid, oid);
|
||||
item->util = old_oid;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -913,9 +915,10 @@ static int do_fetch(struct transport *transport,
|
|||
struct string_list_item *peer_item =
|
||||
string_list_lookup(&existing_refs,
|
||||
rm->peer_ref->name);
|
||||
if (peer_item)
|
||||
hashcpy(rm->peer_ref->old_sha1,
|
||||
peer_item->util);
|
||||
if (peer_item) {
|
||||
struct object_id *old_oid = peer_item->util;
|
||||
hashcpy(rm->peer_ref->old_sha1, old_oid->hash);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -854,7 +854,8 @@ struct grab_ref_cbdata {
|
|||
* A call-back given to for_each_ref(). Filter refs and keep them for
|
||||
* later object processing.
|
||||
*/
|
||||
static int grab_single_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int grab_single_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct grab_ref_cbdata *cb = cb_data;
|
||||
struct refinfo *ref;
|
||||
|
|
@ -892,7 +893,7 @@ static int grab_single_ref(const char *refname, const unsigned char *sha1, int f
|
|||
*/
|
||||
ref = xcalloc(1, sizeof(*ref));
|
||||
ref->refname = xstrdup(refname);
|
||||
hashcpy(ref->objectname, sha1);
|
||||
hashcpy(ref->objectname, oid->hash);
|
||||
ref->flag = flag;
|
||||
|
||||
cnt = cb->grab_cnt;
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ static int include_reflogs = 1;
|
|||
static int check_full = 1;
|
||||
static int check_strict;
|
||||
static int keep_cache_objects;
|
||||
static unsigned char head_sha1[20];
|
||||
static struct object_id head_oid;
|
||||
static const char *head_points_at;
|
||||
static int errors_found;
|
||||
static int write_lost_and_found;
|
||||
|
|
@ -476,19 +476,21 @@ static int fsck_handle_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int fsck_handle_reflog(const char *logname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int fsck_handle_reflog(const char *logname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
for_each_reflog_ent(logname, fsck_handle_reflog_ent, NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fsck_handle_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int fsck_handle_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct object *obj;
|
||||
|
||||
obj = parse_object(sha1);
|
||||
obj = parse_object(oid->hash);
|
||||
if (!obj) {
|
||||
error("%s: invalid sha1 pointer %s", refname, sha1_to_hex(sha1));
|
||||
error("%s: invalid sha1 pointer %s", refname, oid_to_hex(oid));
|
||||
errors_found |= ERROR_REACHABLE;
|
||||
/* We'll continue with the rest despite the error.. */
|
||||
return 0;
|
||||
|
|
@ -504,8 +506,8 @@ static int fsck_handle_ref(const char *refname, const unsigned char *sha1, int f
|
|||
|
||||
static void get_default_heads(void)
|
||||
{
|
||||
if (head_points_at && !is_null_sha1(head_sha1))
|
||||
fsck_handle_ref("HEAD", head_sha1, 0, NULL);
|
||||
if (head_points_at && !is_null_oid(&head_oid))
|
||||
fsck_handle_ref("HEAD", &head_oid, 0, NULL);
|
||||
for_each_rawref(fsck_handle_ref, NULL);
|
||||
if (include_reflogs)
|
||||
for_each_reflog(fsck_handle_reflog, NULL);
|
||||
|
|
@ -556,7 +558,7 @@ static int fsck_head_link(void)
|
|||
if (verbose)
|
||||
fprintf(stderr, "Checking HEAD link\n");
|
||||
|
||||
head_points_at = resolve_ref_unsafe("HEAD", 0, head_sha1, &flag);
|
||||
head_points_at = resolve_ref_unsafe("HEAD", 0, head_oid.hash, &flag);
|
||||
if (!head_points_at)
|
||||
return error("Invalid HEAD");
|
||||
if (!strcmp(head_points_at, "HEAD"))
|
||||
|
|
@ -565,7 +567,7 @@ static int fsck_head_link(void)
|
|||
else if (!starts_with(head_points_at, "refs/heads/"))
|
||||
return error("HEAD points to something strange (%s)",
|
||||
head_points_at);
|
||||
if (is_null_sha1(head_sha1)) {
|
||||
if (is_null_oid(&head_oid)) {
|
||||
if (null_is_error)
|
||||
return error("HEAD: detached HEAD points at nothing");
|
||||
fprintf(stderr, "notice: HEAD points to an unborn branch (%s)\n",
|
||||
|
|
|
|||
|
|
@ -138,9 +138,9 @@ static int tipcmp(const void *a_, const void *b_)
|
|||
return hashcmp(a->sha1, b->sha1);
|
||||
}
|
||||
|
||||
static int name_ref(const char *path, const unsigned char *sha1, int flags, void *cb_data)
|
||||
static int name_ref(const char *path, const struct object_id *oid, int flags, void *cb_data)
|
||||
{
|
||||
struct object *o = parse_object(sha1);
|
||||
struct object *o = parse_object(oid->hash);
|
||||
struct name_ref_data *data = cb_data;
|
||||
int can_abbreviate_output = data->tags_only && data->name_only;
|
||||
int deref = 0;
|
||||
|
|
@ -160,7 +160,7 @@ static int name_ref(const char *path, const unsigned char *sha1, int flags, void
|
|||
}
|
||||
}
|
||||
|
||||
add_to_tip_table(sha1, path, can_abbreviate_output);
|
||||
add_to_tip_table(oid->hash, path, can_abbreviate_output);
|
||||
|
||||
while (o && o->type == OBJ_TAG) {
|
||||
struct tag *t = (struct tag *) o;
|
||||
|
|
|
|||
|
|
@ -540,11 +540,11 @@ static enum write_one_status write_one(struct sha1file *f,
|
|||
return WRITE_ONE_WRITTEN;
|
||||
}
|
||||
|
||||
static int mark_tagged(const char *path, const unsigned char *sha1, int flag,
|
||||
static int mark_tagged(const char *path, const struct object_id *oid, int flag,
|
||||
void *cb_data)
|
||||
{
|
||||
unsigned char peeled[20];
|
||||
struct object_entry *entry = packlist_find(&to_pack, sha1, NULL);
|
||||
struct object_entry *entry = packlist_find(&to_pack, oid->hash, NULL);
|
||||
|
||||
if (entry)
|
||||
entry->tagged = 1;
|
||||
|
|
@ -2097,14 +2097,14 @@ static void ll_find_deltas(struct object_entry **list, unsigned list_size,
|
|||
#define ll_find_deltas(l, s, w, d, p) find_deltas(l, &s, w, d, p)
|
||||
#endif
|
||||
|
||||
static int add_ref_tag(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int add_ref_tag(const char *path, const struct object_id *oid, int flag, void *cb_data)
|
||||
{
|
||||
unsigned char peeled[20];
|
||||
struct object_id peeled;
|
||||
|
||||
if (starts_with(path, "refs/tags/") && /* is a tag? */
|
||||
!peel_ref(path, peeled) && /* peelable? */
|
||||
packlist_find(&to_pack, peeled, NULL)) /* object packed? */
|
||||
add_object_entry(sha1, OBJ_TAG, NULL, 0);
|
||||
!peel_ref(path, peeled.hash) && /* peelable? */
|
||||
packlist_find(&to_pack, peeled.hash, NULL)) /* object packed? */
|
||||
add_object_entry(oid->hash, OBJ_TAG, NULL, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -197,7 +197,7 @@ static void show_ref(const char *path, const unsigned char *sha1)
|
|||
}
|
||||
}
|
||||
|
||||
static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
|
||||
static int show_ref_cb(const char *path, const struct object_id *oid, int flag, void *unused)
|
||||
{
|
||||
path = strip_namespace(path);
|
||||
/*
|
||||
|
|
@ -210,7 +210,7 @@ static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, vo
|
|||
*/
|
||||
if (!path)
|
||||
path = ".have";
|
||||
show_ref(path, sha1);
|
||||
show_ref(path, oid->hash);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -228,6 +228,7 @@ static void collect_one_alternate_ref(const struct ref *ref, void *data)
|
|||
static void write_head_info(void)
|
||||
{
|
||||
struct sha1_array sa = SHA1_ARRAY_INIT;
|
||||
|
||||
for_each_alternate_ref(collect_one_alternate_ref, &sa);
|
||||
sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
|
||||
sha1_array_clear(&sa);
|
||||
|
|
|
|||
|
|
@ -313,14 +313,14 @@ static int should_expire_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int push_tip_to_list(const char *refname, const unsigned char *sha1,
|
||||
static int push_tip_to_list(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
struct commit_list **list = cb_data;
|
||||
struct commit *tip_commit;
|
||||
if (flags & REF_ISSYMREF)
|
||||
return 0;
|
||||
tip_commit = lookup_commit_reference_gently(sha1, 1);
|
||||
tip_commit = lookup_commit_reference_gently(oid->hash, 1);
|
||||
if (!tip_commit)
|
||||
return 0;
|
||||
commit_list_insert(tip_commit, list);
|
||||
|
|
@ -352,6 +352,7 @@ static void reflog_expiry_prepare(const char *refname,
|
|||
if (cb->unreachable_expire_kind != UE_ALWAYS) {
|
||||
if (cb->unreachable_expire_kind == UE_HEAD) {
|
||||
struct commit_list *elem;
|
||||
|
||||
for_each_ref(push_tip_to_list, &cb->tips);
|
||||
for (elem = cb->tips; elem; elem = elem->next)
|
||||
commit_list_insert(elem->item, &cb->mark_list);
|
||||
|
|
@ -379,14 +380,14 @@ static void reflog_expiry_cleanup(void *cb_data)
|
|||
}
|
||||
}
|
||||
|
||||
static int collect_reflog(const char *ref, const unsigned char *sha1, int unused, void *cb_data)
|
||||
static int collect_reflog(const char *ref, const struct object_id *oid, int unused, void *cb_data)
|
||||
{
|
||||
struct collected_reflog *e;
|
||||
struct collect_reflog_cb *cb = cb_data;
|
||||
size_t namelen = strlen(ref);
|
||||
|
||||
e = xmalloc(sizeof(*e) + namelen + 1);
|
||||
hashcpy(e->sha1, sha1);
|
||||
hashcpy(e->sha1, oid->hash);
|
||||
memcpy(e->reflog, ref, namelen + 1);
|
||||
ALLOC_GROW(cb->e, cb->nr + 1, cb->alloc);
|
||||
cb->e[cb->nr++] = e;
|
||||
|
|
|
|||
|
|
@ -509,11 +509,10 @@ struct branches_for_remote {
|
|||
};
|
||||
|
||||
static int add_branch_for_removal(const char *refname,
|
||||
const unsigned char *sha1, int flags, void *cb_data)
|
||||
const struct object_id *oid, int flags, void *cb_data)
|
||||
{
|
||||
struct branches_for_remote *branches = cb_data;
|
||||
struct refspec refspec;
|
||||
struct string_list_item *item;
|
||||
struct known_remote *kr;
|
||||
|
||||
memset(&refspec, 0, sizeof(refspec));
|
||||
|
|
@ -543,9 +542,7 @@ static int add_branch_for_removal(const char *refname,
|
|||
if (flags & REF_ISSYMREF)
|
||||
return unlink(git_path("%s", refname));
|
||||
|
||||
item = string_list_append(branches->branches, refname);
|
||||
item->util = xmalloc(20);
|
||||
hashcpy(item->util, sha1);
|
||||
string_list_append(branches->branches, refname);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -557,20 +554,20 @@ struct rename_info {
|
|||
};
|
||||
|
||||
static int read_remote_branches(const char *refname,
|
||||
const unsigned char *sha1, int flags, void *cb_data)
|
||||
const struct object_id *oid, int flags, void *cb_data)
|
||||
{
|
||||
struct rename_info *rename = cb_data;
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
struct string_list_item *item;
|
||||
int flag;
|
||||
unsigned char orig_sha1[20];
|
||||
struct object_id orig_oid;
|
||||
const char *symref;
|
||||
|
||||
strbuf_addf(&buf, "refs/remotes/%s/", rename->old);
|
||||
if (starts_with(refname, buf.buf)) {
|
||||
item = string_list_append(rename->remote_branches, xstrdup(refname));
|
||||
symref = resolve_ref_unsafe(refname, RESOLVE_REF_READING,
|
||||
orig_sha1, &flag);
|
||||
orig_oid.hash, &flag);
|
||||
if (flag & REF_ISSYMREF)
|
||||
item->util = xstrdup(symref);
|
||||
else
|
||||
|
|
@ -704,9 +701,9 @@ static int mv(int argc, const char **argv)
|
|||
for (i = 0; i < remote_branches.nr; i++) {
|
||||
struct string_list_item *item = remote_branches.items + i;
|
||||
int flag = 0;
|
||||
unsigned char sha1[20];
|
||||
struct object_id oid;
|
||||
|
||||
read_ref_full(item->string, RESOLVE_REF_READING, sha1, &flag);
|
||||
read_ref_full(item->string, RESOLVE_REF_READING, oid.hash, &flag);
|
||||
if (!(flag & REF_ISSYMREF))
|
||||
continue;
|
||||
if (delete_ref(item->string, NULL, REF_NODEREF))
|
||||
|
|
@ -826,7 +823,7 @@ static int rm(int argc, const char **argv)
|
|||
|
||||
if (!result)
|
||||
result = remove_branches(&branches);
|
||||
string_list_clear(&branches, 1);
|
||||
string_list_clear(&branches, 0);
|
||||
|
||||
if (skipped.nr) {
|
||||
fprintf_ln(stderr,
|
||||
|
|
@ -867,7 +864,7 @@ static void free_remote_ref_states(struct ref_states *states)
|
|||
}
|
||||
|
||||
static int append_ref_to_tracked_list(const char *refname,
|
||||
const unsigned char *sha1, int flags, void *cb_data)
|
||||
const struct object_id *oid, int flags, void *cb_data)
|
||||
{
|
||||
struct ref_states *states = cb_data;
|
||||
struct refspec refspec;
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ struct show_data {
|
|||
enum replace_format format;
|
||||
};
|
||||
|
||||
static int show_reference(const char *refname, const unsigned char *sha1,
|
||||
static int show_reference(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct show_data *data = cb_data;
|
||||
|
|
@ -44,19 +44,19 @@ static int show_reference(const char *refname, const unsigned char *sha1,
|
|||
if (data->format == REPLACE_FORMAT_SHORT)
|
||||
printf("%s\n", refname);
|
||||
else if (data->format == REPLACE_FORMAT_MEDIUM)
|
||||
printf("%s -> %s\n", refname, sha1_to_hex(sha1));
|
||||
printf("%s -> %s\n", refname, oid_to_hex(oid));
|
||||
else { /* data->format == REPLACE_FORMAT_LONG */
|
||||
unsigned char object[20];
|
||||
struct object_id object;
|
||||
enum object_type obj_type, repl_type;
|
||||
|
||||
if (get_sha1(refname, object))
|
||||
if (get_sha1(refname, object.hash))
|
||||
return error("Failed to resolve '%s' as a valid ref.", refname);
|
||||
|
||||
obj_type = sha1_object_info(object, NULL);
|
||||
repl_type = sha1_object_info(sha1, NULL);
|
||||
obj_type = sha1_object_info(object.hash, NULL);
|
||||
repl_type = sha1_object_info(oid->hash, NULL);
|
||||
|
||||
printf("%s (%s) -> %s (%s)\n", refname, typename(obj_type),
|
||||
sha1_to_hex(sha1), typename(repl_type));
|
||||
oid_to_hex(oid), typename(repl_type));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -82,7 +82,7 @@ static int list_replace_refs(const char *pattern, const char *format)
|
|||
"valid formats are 'short', 'medium' and 'long'\n",
|
||||
format);
|
||||
|
||||
for_each_replace_ref(show_reference, (void *) &data);
|
||||
for_each_replace_ref(show_reference, (void *)&data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -190,17 +190,17 @@ static int show_default(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int show_reference(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int show_reference(const char *refname, const struct object_id *oid, int flag, void *cb_data)
|
||||
{
|
||||
if (ref_excluded(ref_excludes, refname))
|
||||
return 0;
|
||||
show_rev(NORMAL, sha1, refname);
|
||||
show_rev(NORMAL, oid->hash, refname);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int anti_reference(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int anti_reference(const char *refname, const struct object_id *oid, int flag, void *cb_data)
|
||||
{
|
||||
show_rev(REVERSED, sha1, refname);
|
||||
show_rev(REVERSED, oid->hash, refname);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -369,10 +369,10 @@ static void sort_ref_range(int bottom, int top)
|
|||
compare_ref_name);
|
||||
}
|
||||
|
||||
static int append_ref(const char *refname, const unsigned char *sha1,
|
||||
static int append_ref(const char *refname, const struct object_id *oid,
|
||||
int allow_dups)
|
||||
{
|
||||
struct commit *commit = lookup_commit_reference_gently(sha1, 1);
|
||||
struct commit *commit = lookup_commit_reference_gently(oid->hash, 1);
|
||||
int i;
|
||||
|
||||
if (!commit)
|
||||
|
|
@ -394,39 +394,42 @@ static int append_ref(const char *refname, const unsigned char *sha1,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int append_head_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int append_head_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
unsigned char tmp[20];
|
||||
struct object_id tmp;
|
||||
int ofs = 11;
|
||||
if (!starts_with(refname, "refs/heads/"))
|
||||
return 0;
|
||||
/* If both heads/foo and tags/foo exists, get_sha1 would
|
||||
* get confused.
|
||||
*/
|
||||
if (get_sha1(refname + ofs, tmp) || hashcmp(tmp, sha1))
|
||||
if (get_sha1(refname + ofs, tmp.hash) || oidcmp(&tmp, oid))
|
||||
ofs = 5;
|
||||
return append_ref(refname + ofs, sha1, 0);
|
||||
return append_ref(refname + ofs, oid, 0);
|
||||
}
|
||||
|
||||
static int append_remote_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int append_remote_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
unsigned char tmp[20];
|
||||
struct object_id tmp;
|
||||
int ofs = 13;
|
||||
if (!starts_with(refname, "refs/remotes/"))
|
||||
return 0;
|
||||
/* If both heads/foo and tags/foo exists, get_sha1 would
|
||||
* get confused.
|
||||
*/
|
||||
if (get_sha1(refname + ofs, tmp) || hashcmp(tmp, sha1))
|
||||
if (get_sha1(refname + ofs, tmp.hash) || oidcmp(&tmp, oid))
|
||||
ofs = 5;
|
||||
return append_ref(refname + ofs, sha1, 0);
|
||||
return append_ref(refname + ofs, oid, 0);
|
||||
}
|
||||
|
||||
static int append_tag_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int append_tag_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
if (!starts_with(refname, "refs/tags/"))
|
||||
return 0;
|
||||
return append_ref(refname + 5, sha1, 0);
|
||||
return append_ref(refname + 5, oid, 0);
|
||||
}
|
||||
|
||||
static const char *match_ref_pattern = NULL;
|
||||
|
|
@ -440,7 +443,8 @@ static int count_slash(const char *s)
|
|||
return cnt;
|
||||
}
|
||||
|
||||
static int append_matching_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int append_matching_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
/* we want to allow pattern hold/<asterisk> to show all
|
||||
* branches under refs/heads/hold/, and v0.99.9? to show
|
||||
|
|
@ -456,21 +460,23 @@ static int append_matching_ref(const char *refname, const unsigned char *sha1, i
|
|||
if (wildmatch(match_ref_pattern, tail, 0, NULL))
|
||||
return 0;
|
||||
if (starts_with(refname, "refs/heads/"))
|
||||
return append_head_ref(refname, sha1, flag, cb_data);
|
||||
return append_head_ref(refname, oid, flag, cb_data);
|
||||
if (starts_with(refname, "refs/tags/"))
|
||||
return append_tag_ref(refname, sha1, flag, cb_data);
|
||||
return append_ref(refname, sha1, 0);
|
||||
return append_tag_ref(refname, oid, flag, cb_data);
|
||||
return append_ref(refname, oid, 0);
|
||||
}
|
||||
|
||||
static void snarf_refs(int head, int remotes)
|
||||
{
|
||||
if (head) {
|
||||
int orig_cnt = ref_name_cnt;
|
||||
|
||||
for_each_ref(append_head_ref, NULL);
|
||||
sort_ref_range(orig_cnt, ref_name_cnt);
|
||||
}
|
||||
if (remotes) {
|
||||
int orig_cnt = ref_name_cnt;
|
||||
|
||||
for_each_ref(append_remote_ref, NULL);
|
||||
sort_ref_range(orig_cnt, ref_name_cnt);
|
||||
}
|
||||
|
|
@ -530,14 +536,15 @@ static int show_independent(struct commit **rev,
|
|||
|
||||
static void append_one_rev(const char *av)
|
||||
{
|
||||
unsigned char revkey[20];
|
||||
if (!get_sha1(av, revkey)) {
|
||||
append_ref(av, revkey, 0);
|
||||
struct object_id revkey;
|
||||
if (!get_sha1(av, revkey.hash)) {
|
||||
append_ref(av, &revkey, 0);
|
||||
return;
|
||||
}
|
||||
if (strchr(av, '*') || strchr(av, '?') || strchr(av, '[')) {
|
||||
/* glob style match */
|
||||
int saved_matches = ref_name_cnt;
|
||||
|
||||
match_ref_pattern = av;
|
||||
match_ref_slash = count_slash(av);
|
||||
for_each_ref(append_matching_ref, NULL);
|
||||
|
|
@ -636,7 +643,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
char head[128];
|
||||
const char *head_p;
|
||||
int head_len;
|
||||
unsigned char head_sha1[20];
|
||||
struct object_id head_oid;
|
||||
int merge_base = 0;
|
||||
int independent = 0;
|
||||
int no_name = 0;
|
||||
|
|
@ -722,7 +729,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
all_heads = 1;
|
||||
|
||||
if (reflog) {
|
||||
unsigned char sha1[20];
|
||||
struct object_id oid;
|
||||
char nth_desc[256];
|
||||
char *ref;
|
||||
int base = 0;
|
||||
|
|
@ -733,7 +740,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
|
||||
fake_av[0] = resolve_refdup("HEAD",
|
||||
RESOLVE_REF_READING,
|
||||
sha1, NULL);
|
||||
oid.hash, NULL);
|
||||
fake_av[1] = NULL;
|
||||
av = fake_av;
|
||||
ac = 1;
|
||||
|
|
@ -744,7 +751,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
if (MAX_REVS < reflog)
|
||||
die("Only %d entries can be shown at one time.",
|
||||
MAX_REVS);
|
||||
if (!dwim_ref(*av, strlen(*av), sha1, &ref))
|
||||
if (!dwim_ref(*av, strlen(*av), oid.hash, &ref))
|
||||
die("No such ref %s", *av);
|
||||
|
||||
/* Has the base been specified? */
|
||||
|
|
@ -755,7 +762,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
/* Ah, that is a date spec... */
|
||||
unsigned long at;
|
||||
at = approxidate(reflog_base);
|
||||
read_ref_at(ref, flags, at, -1, sha1, NULL,
|
||||
read_ref_at(ref, flags, at, -1, oid.hash, NULL,
|
||||
NULL, NULL, &base);
|
||||
}
|
||||
}
|
||||
|
|
@ -766,7 +773,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
unsigned long timestamp;
|
||||
int tz;
|
||||
|
||||
if (read_ref_at(ref, flags, 0, base+i, sha1, &logmsg,
|
||||
if (read_ref_at(ref, flags, 0, base+i, oid.hash, &logmsg,
|
||||
×tamp, &tz, NULL)) {
|
||||
reflog = i;
|
||||
break;
|
||||
|
|
@ -781,7 +788,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
msg);
|
||||
free(logmsg);
|
||||
sprintf(nth_desc, "%s@{%d}", *av, base+i);
|
||||
append_ref(nth_desc, sha1, 1);
|
||||
append_ref(nth_desc, &oid, 1);
|
||||
}
|
||||
free(ref);
|
||||
}
|
||||
|
|
@ -795,7 +802,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
}
|
||||
|
||||
head_p = resolve_ref_unsafe("HEAD", RESOLVE_REF_READING,
|
||||
head_sha1, NULL);
|
||||
head_oid.hash, NULL);
|
||||
if (head_p) {
|
||||
head_len = strlen(head_p);
|
||||
memcpy(head, head_p, head_len + 1);
|
||||
|
|
@ -814,7 +821,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
if (rev_is_head(head,
|
||||
head_len,
|
||||
ref_name[i],
|
||||
head_sha1, NULL))
|
||||
head_oid.hash, NULL))
|
||||
has_head++;
|
||||
}
|
||||
if (!has_head) {
|
||||
|
|
@ -829,17 +836,17 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
}
|
||||
|
||||
for (num_rev = 0; ref_name[num_rev]; num_rev++) {
|
||||
unsigned char revkey[20];
|
||||
struct object_id revkey;
|
||||
unsigned int flag = 1u << (num_rev + REV_SHIFT);
|
||||
|
||||
if (MAX_REVS <= num_rev)
|
||||
die("cannot handle more than %d revs.", MAX_REVS);
|
||||
if (get_sha1(ref_name[num_rev], revkey))
|
||||
if (get_sha1(ref_name[num_rev], revkey.hash))
|
||||
die("'%s' is not a valid ref.", ref_name[num_rev]);
|
||||
commit = lookup_commit_reference(revkey);
|
||||
commit = lookup_commit_reference(revkey.hash);
|
||||
if (!commit)
|
||||
die("cannot find commit %s (%s)",
|
||||
ref_name[num_rev], revkey);
|
||||
ref_name[num_rev], oid_to_hex(&revkey));
|
||||
parse_commit(commit);
|
||||
mark_seen(commit, &seen);
|
||||
|
||||
|
|
@ -873,7 +880,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
int is_head = rev_is_head(head,
|
||||
head_len,
|
||||
ref_name[i],
|
||||
head_sha1,
|
||||
head_oid.hash,
|
||||
rev[i]->object.sha1);
|
||||
if (extra < 0)
|
||||
printf("%c [%s] ",
|
||||
|
|
|
|||
|
|
@ -17,19 +17,20 @@ static int deref_tags, show_head, tags_only, heads_only, found_match, verify,
|
|||
static const char **pattern;
|
||||
static const char *exclude_existing_arg;
|
||||
|
||||
static void show_one(const char *refname, const unsigned char *sha1)
|
||||
static void show_one(const char *refname, const struct object_id *oid)
|
||||
{
|
||||
const char *hex = find_unique_abbrev(sha1, abbrev);
|
||||
const char *hex = find_unique_abbrev(oid->hash, abbrev);
|
||||
if (hash_only)
|
||||
printf("%s\n", hex);
|
||||
else
|
||||
printf("%s %s\n", hex, refname);
|
||||
}
|
||||
|
||||
static int show_ref(const char *refname, const unsigned char *sha1, int flag, void *cbdata)
|
||||
static int show_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cbdata)
|
||||
{
|
||||
const char *hex;
|
||||
unsigned char peeled[20];
|
||||
struct object_id peeled;
|
||||
|
||||
if (show_head && !strcmp(refname, "HEAD"))
|
||||
goto match;
|
||||
|
|
@ -69,26 +70,27 @@ match:
|
|||
* detect and return error if the repository is corrupt and
|
||||
* ref points at a nonexistent object.
|
||||
*/
|
||||
if (!has_sha1_file(sha1))
|
||||
if (!has_sha1_file(oid->hash))
|
||||
die("git show-ref: bad ref %s (%s)", refname,
|
||||
sha1_to_hex(sha1));
|
||||
oid_to_hex(oid));
|
||||
|
||||
if (quiet)
|
||||
return 0;
|
||||
|
||||
show_one(refname, sha1);
|
||||
show_one(refname, oid);
|
||||
|
||||
if (!deref_tags)
|
||||
return 0;
|
||||
|
||||
if (!peel_ref(refname, peeled)) {
|
||||
hex = find_unique_abbrev(peeled, abbrev);
|
||||
if (!peel_ref(refname, peeled.hash)) {
|
||||
hex = find_unique_abbrev(peeled.hash, abbrev);
|
||||
printf("%s %s^{}\n", hex, refname);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int add_existing(const char *refname, const unsigned char *sha1, int flag, void *cbdata)
|
||||
static int add_existing(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cbdata)
|
||||
{
|
||||
struct string_list *list = (struct string_list *)cbdata;
|
||||
string_list_insert(list, refname);
|
||||
|
|
@ -208,12 +210,12 @@ int cmd_show_ref(int argc, const char **argv, const char *prefix)
|
|||
if (!pattern)
|
||||
die("--verify requires a reference");
|
||||
while (*pattern) {
|
||||
unsigned char sha1[20];
|
||||
struct object_id oid;
|
||||
|
||||
if (starts_with(*pattern, "refs/") &&
|
||||
!read_ref(*pattern, sha1)) {
|
||||
!read_ref(*pattern, oid.hash)) {
|
||||
if (!quiet)
|
||||
show_one(*pattern, sha1);
|
||||
show_one(*pattern, &oid);
|
||||
}
|
||||
else if (!quiet)
|
||||
die("'%s' - not a valid ref", *pattern);
|
||||
|
|
|
|||
|
|
@ -176,7 +176,7 @@ static enum contains_result contains(struct commit *candidate,
|
|||
return contains_test(candidate, want);
|
||||
}
|
||||
|
||||
static void show_tag_lines(const unsigned char *sha1, int lines)
|
||||
static void show_tag_lines(const struct object_id *oid, int lines)
|
||||
{
|
||||
int i;
|
||||
unsigned long size;
|
||||
|
|
@ -184,14 +184,14 @@ static void show_tag_lines(const unsigned char *sha1, int lines)
|
|||
char *buf, *sp, *eol;
|
||||
size_t len;
|
||||
|
||||
buf = read_sha1_file(sha1, &type, &size);
|
||||
buf = read_sha1_file(oid->hash, &type, &size);
|
||||
if (!buf)
|
||||
die_errno("unable to read object %s", sha1_to_hex(sha1));
|
||||
die_errno("unable to read object %s", oid_to_hex(oid));
|
||||
if (type != OBJ_COMMIT && type != OBJ_TAG)
|
||||
goto free_return;
|
||||
if (!size)
|
||||
die("an empty %s object %s?",
|
||||
typename(type), sha1_to_hex(sha1));
|
||||
typename(type), oid_to_hex(oid));
|
||||
|
||||
/* skip header */
|
||||
sp = strstr(buf, "\n\n");
|
||||
|
|
@ -215,7 +215,7 @@ free_return:
|
|||
free(buf);
|
||||
}
|
||||
|
||||
static int show_reference(const char *refname, const unsigned char *sha1,
|
||||
static int show_reference(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct tag_filter *filter = cb_data;
|
||||
|
|
@ -224,14 +224,14 @@ static int show_reference(const char *refname, const unsigned char *sha1,
|
|||
if (filter->with_commit) {
|
||||
struct commit *commit;
|
||||
|
||||
commit = lookup_commit_reference_gently(sha1, 1);
|
||||
commit = lookup_commit_reference_gently(oid->hash, 1);
|
||||
if (!commit)
|
||||
return 0;
|
||||
if (!contains(commit, filter->with_commit))
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (points_at.nr && !match_points_at(refname, sha1))
|
||||
if (points_at.nr && !match_points_at(refname, oid->hash))
|
||||
return 0;
|
||||
|
||||
if (!filter->lines) {
|
||||
|
|
@ -242,7 +242,7 @@ static int show_reference(const char *refname, const unsigned char *sha1,
|
|||
return 0;
|
||||
}
|
||||
printf("%-15s ", refname);
|
||||
show_tag_lines(sha1, filter->lines);
|
||||
show_tag_lines(oid, filter->lines);
|
||||
putchar('\n');
|
||||
}
|
||||
|
||||
|
|
@ -268,7 +268,7 @@ static int list_tags(const char **patterns, int lines,
|
|||
memset(&filter.tags, 0, sizeof(filter.tags));
|
||||
filter.tags.strdup_strings = 1;
|
||||
|
||||
for_each_tag_ref(show_reference, (void *) &filter);
|
||||
for_each_tag_ref(show_reference, (void *)&filter);
|
||||
if (sort) {
|
||||
int i;
|
||||
if ((sort & SORT_MASK) == VERCMP_SORT)
|
||||
|
|
|
|||
29
fetch-pack.c
29
fetch-pack.c
|
|
@ -65,7 +65,7 @@ static void rev_list_push(struct commit *commit, int mark)
|
|||
}
|
||||
}
|
||||
|
||||
static int rev_list_insert_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int rev_list_insert_ref(const char *refname, const unsigned char *sha1)
|
||||
{
|
||||
struct object *o = deref_tag(parse_object(sha1), refname, 0);
|
||||
|
||||
|
|
@ -75,9 +75,16 @@ static int rev_list_insert_ref(const char *refname, const unsigned char *sha1, i
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int clear_marks(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int rev_list_insert_ref_oid(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct object *o = deref_tag(parse_object(sha1), refname, 0);
|
||||
return rev_list_insert_ref(refname, oid->hash);
|
||||
}
|
||||
|
||||
static int clear_marks(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct object *o = deref_tag(parse_object(oid->hash), refname, 0);
|
||||
|
||||
if (o && o->type == OBJ_COMMIT)
|
||||
clear_commit_marks((struct commit *)o,
|
||||
|
|
@ -231,7 +238,7 @@ static void send_request(struct fetch_pack_args *args,
|
|||
|
||||
static void insert_one_alternate_ref(const struct ref *ref, void *unused)
|
||||
{
|
||||
rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
|
||||
rev_list_insert_ref(NULL, ref->old_sha1);
|
||||
}
|
||||
|
||||
#define INITIAL_FLUSH 16
|
||||
|
|
@ -268,7 +275,7 @@ static int find_common(struct fetch_pack_args *args,
|
|||
for_each_ref(clear_marks, NULL);
|
||||
marked = 1;
|
||||
|
||||
for_each_ref(rev_list_insert_ref, NULL);
|
||||
for_each_ref(rev_list_insert_ref_oid, NULL);
|
||||
for_each_alternate_ref(insert_one_alternate_ref, NULL);
|
||||
|
||||
fetching = 0;
|
||||
|
|
@ -471,7 +478,7 @@ done:
|
|||
|
||||
static struct commit_list *complete;
|
||||
|
||||
static int mark_complete(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int mark_complete(const unsigned char *sha1)
|
||||
{
|
||||
struct object *o = parse_object(sha1);
|
||||
|
||||
|
|
@ -492,6 +499,12 @@ static int mark_complete(const char *refname, const unsigned char *sha1, int fla
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int mark_complete_oid(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
return mark_complete(oid->hash);
|
||||
}
|
||||
|
||||
static void mark_recent_complete_commits(struct fetch_pack_args *args,
|
||||
unsigned long cutoff)
|
||||
{
|
||||
|
|
@ -570,7 +583,7 @@ static void filter_refs(struct fetch_pack_args *args,
|
|||
|
||||
static void mark_alternate_complete(const struct ref *ref, void *unused)
|
||||
{
|
||||
mark_complete(NULL, ref->old_sha1, 0, NULL);
|
||||
mark_complete(ref->old_sha1);
|
||||
}
|
||||
|
||||
static int everything_local(struct fetch_pack_args *args,
|
||||
|
|
@ -605,7 +618,7 @@ static int everything_local(struct fetch_pack_args *args,
|
|||
}
|
||||
|
||||
if (!args->depth) {
|
||||
for_each_ref(mark_complete, NULL);
|
||||
for_each_ref(mark_complete_oid, NULL);
|
||||
for_each_alternate_ref(mark_alternate_complete, NULL);
|
||||
commit_list_sort_by_date(&complete);
|
||||
if (cutoff)
|
||||
|
|
|
|||
2
help.c
2
help.c
|
|
@ -429,7 +429,7 @@ struct similar_ref_cb {
|
|||
struct string_list *similar_refs;
|
||||
};
|
||||
|
||||
static int append_similar_ref(const char *refname, const unsigned char *sha1,
|
||||
static int append_similar_ref(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
struct similar_ref_cb *cb = (struct similar_ref_cb *)(cb_data);
|
||||
|
|
|
|||
|
|
@ -421,16 +421,16 @@ static void run_service(const char **argv, int buffer_input)
|
|||
exit(1);
|
||||
}
|
||||
|
||||
static int show_text_ref(const char *name, const unsigned char *sha1,
|
||||
int flag, void *cb_data)
|
||||
static int show_text_ref(const char *name, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
const char *name_nons = strip_namespace(name);
|
||||
struct strbuf *buf = cb_data;
|
||||
struct object *o = parse_object(sha1);
|
||||
struct object *o = parse_object(oid->hash);
|
||||
if (!o)
|
||||
return 0;
|
||||
|
||||
strbuf_addf(buf, "%s\t%s\n", sha1_to_hex(sha1), name_nons);
|
||||
strbuf_addf(buf, "%s\t%s\n", oid_to_hex(oid), name_nons);
|
||||
if (o->type == OBJ_TAG) {
|
||||
o = deref_tag(o, name, 0);
|
||||
if (!o)
|
||||
|
|
@ -473,21 +473,21 @@ static void get_info_refs(char *arg)
|
|||
strbuf_release(&buf);
|
||||
}
|
||||
|
||||
static int show_head_ref(const char *refname, const unsigned char *sha1,
|
||||
int flag, void *cb_data)
|
||||
static int show_head_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct strbuf *buf = cb_data;
|
||||
|
||||
if (flag & REF_ISSYMREF) {
|
||||
unsigned char unused[20];
|
||||
struct object_id unused;
|
||||
const char *target = resolve_ref_unsafe(refname,
|
||||
RESOLVE_REF_READING,
|
||||
unused, NULL);
|
||||
unused.hash, NULL);
|
||||
const char *target_nons = strip_namespace(target);
|
||||
|
||||
strbuf_addf(buf, "ref: %s\n", target_nons);
|
||||
} else {
|
||||
strbuf_addf(buf, "%s\n", sha1_to_hex(sha1));
|
||||
strbuf_addf(buf, "%s\n", oid_to_hex(oid));
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
12
log-tree.c
12
log-tree.c
|
|
@ -89,7 +89,8 @@ const struct name_decoration *get_name_decoration(const struct object *obj)
|
|||
return lookup_decoration(&name_decoration, obj);
|
||||
}
|
||||
|
||||
static int add_ref_decoration(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
|
||||
static int add_ref_decoration(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
struct object *obj;
|
||||
enum decoration_type type = DECORATION_NONE;
|
||||
|
|
@ -97,20 +98,20 @@ static int add_ref_decoration(const char *refname, const unsigned char *sha1, in
|
|||
assert(cb_data == NULL);
|
||||
|
||||
if (starts_with(refname, "refs/replace/")) {
|
||||
unsigned char original_sha1[20];
|
||||
struct object_id original_oid;
|
||||
if (!check_replace_refs)
|
||||
return 0;
|
||||
if (get_sha1_hex(refname + 13, original_sha1)) {
|
||||
if (get_oid_hex(refname + 13, &original_oid)) {
|
||||
warning("invalid replace ref %s", refname);
|
||||
return 0;
|
||||
}
|
||||
obj = parse_object(original_sha1);
|
||||
obj = parse_object(original_oid.hash);
|
||||
if (obj)
|
||||
add_name_decoration(DECORATION_GRAFTED, "replaced", obj);
|
||||
return 0;
|
||||
}
|
||||
|
||||
obj = parse_object(sha1);
|
||||
obj = parse_object(oid->hash);
|
||||
if (!obj)
|
||||
return 0;
|
||||
|
||||
|
|
@ -149,6 +150,7 @@ static int add_graft_decoration(const struct commit_graft *graft, void *cb_data)
|
|||
void load_ref_decorations(int flags)
|
||||
{
|
||||
if (!decoration_loaded) {
|
||||
|
||||
decoration_loaded = 1;
|
||||
decoration_flags = flags;
|
||||
for_each_ref(add_ref_decoration, NULL);
|
||||
|
|
|
|||
2
notes.c
2
notes.c
|
|
@ -918,7 +918,7 @@ out:
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int string_list_add_one_ref(const char *refname, const unsigned char *sha1,
|
||||
static int string_list_add_one_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb)
|
||||
{
|
||||
struct string_list *refs = cb;
|
||||
|
|
|
|||
|
|
@ -22,9 +22,10 @@ static void update_progress(struct connectivity_progress *cp)
|
|||
display_progress(cp->progress, cp->count);
|
||||
}
|
||||
|
||||
static int add_one_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int add_one_ref(const char *path, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct object *object = parse_object_or_die(sha1, path);
|
||||
struct object *object = parse_object_or_die(oid->hash, path);
|
||||
struct rev_info *revs = (struct rev_info *)cb_data;
|
||||
|
||||
add_pending_object(revs, object, "");
|
||||
|
|
|
|||
104
refs.c
104
refs.c
|
|
@ -10,7 +10,7 @@ struct ref_lock {
|
|||
char *ref_name;
|
||||
char *orig_ref_name;
|
||||
struct lock_file *lk;
|
||||
unsigned char old_sha1[20];
|
||||
struct object_id old_oid;
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -161,7 +161,7 @@ struct ref_value {
|
|||
* null. If REF_ISSYMREF, then this is the name of the object
|
||||
* referred to by the last reference in the symlink chain.
|
||||
*/
|
||||
unsigned char sha1[20];
|
||||
struct object_id oid;
|
||||
|
||||
/*
|
||||
* If REF_KNOWS_PEELED, then this field holds the peeled value
|
||||
|
|
@ -169,7 +169,7 @@ struct ref_value {
|
|||
* be peelable. See the documentation for peel_ref() for an
|
||||
* exact definition of "peelable".
|
||||
*/
|
||||
unsigned char peeled[20];
|
||||
struct object_id peeled;
|
||||
};
|
||||
|
||||
struct ref_cache;
|
||||
|
|
@ -351,8 +351,8 @@ static struct ref_entry *create_ref_entry(const char *refname,
|
|||
die("Reference has invalid format: '%s'", refname);
|
||||
len = strlen(refname) + 1;
|
||||
ref = xmalloc(sizeof(struct ref_entry) + len);
|
||||
hashcpy(ref->u.value.sha1, sha1);
|
||||
hashclr(ref->u.value.peeled);
|
||||
hashcpy(ref->u.value.oid.hash, sha1);
|
||||
oidclr(&ref->u.value.peeled);
|
||||
memcpy(ref->name, refname, len);
|
||||
ref->flag = flag;
|
||||
return ref;
|
||||
|
|
@ -626,7 +626,7 @@ static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2
|
|||
/* This is impossible by construction */
|
||||
die("Reference directory conflict: %s", ref1->name);
|
||||
|
||||
if (hashcmp(ref1->u.value.sha1, ref2->u.value.sha1))
|
||||
if (oidcmp(&ref1->u.value.oid, &ref2->u.value.oid))
|
||||
die("Duplicated ref, and SHA1s don't match: %s", ref1->name);
|
||||
|
||||
warning("Duplicated ref: %s", ref1->name);
|
||||
|
|
@ -674,7 +674,7 @@ static int ref_resolves_to_object(struct ref_entry *entry)
|
|||
{
|
||||
if (entry->flag & REF_ISBROKEN)
|
||||
return 0;
|
||||
if (!has_sha1_file(entry->u.value.sha1)) {
|
||||
if (!has_sha1_file(entry->u.value.oid.hash)) {
|
||||
error("%s does not point to a valid object!", entry->name);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -722,7 +722,7 @@ static int do_one_ref(struct ref_entry *entry, void *cb_data)
|
|||
/* Store the old value, in case this is a recursive call: */
|
||||
old_current_ref = current_ref;
|
||||
current_ref = entry;
|
||||
retval = data->fn(entry->name + data->trim, entry->u.value.sha1,
|
||||
retval = data->fn(entry->name + data->trim, &entry->u.value.oid,
|
||||
entry->flag, data->cb_data);
|
||||
current_ref = old_current_ref;
|
||||
return retval;
|
||||
|
|
@ -1258,7 +1258,7 @@ static void read_packed_refs(FILE *f, struct ref_dir *dir)
|
|||
line.len == PEELED_LINE_LENGTH &&
|
||||
line.buf[PEELED_LINE_LENGTH - 1] == '\n' &&
|
||||
!get_sha1_hex(line.buf + 1, sha1)) {
|
||||
hashcpy(last->u.value.peeled, sha1);
|
||||
hashcpy(last->u.value.peeled.hash, sha1);
|
||||
/*
|
||||
* Regardless of what the file header said,
|
||||
* we definitely know the value of *this*
|
||||
|
|
@ -1439,7 +1439,7 @@ static int resolve_gitlink_packed_ref(struct ref_cache *refs,
|
|||
if (ref == NULL)
|
||||
return -1;
|
||||
|
||||
hashcpy(sha1, ref->u.value.sha1);
|
||||
hashcpy(sha1, ref->u.value.oid.hash);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1526,7 +1526,7 @@ static int resolve_missing_loose_ref(const char *refname,
|
|||
*/
|
||||
entry = get_packed_ref(refname);
|
||||
if (entry) {
|
||||
hashcpy(sha1, entry->u.value.sha1);
|
||||
hashcpy(sha1, entry->u.value.oid.hash);
|
||||
if (flags)
|
||||
*flags |= REF_ISPACKED;
|
||||
return 0;
|
||||
|
|
@ -1756,13 +1756,14 @@ int ref_exists(const char *refname)
|
|||
return !!resolve_ref_unsafe(refname, RESOLVE_REF_READING, sha1, NULL);
|
||||
}
|
||||
|
||||
static int filter_refs(const char *refname, const unsigned char *sha1, int flags,
|
||||
void *data)
|
||||
static int filter_refs(const char *refname, const struct object_id *oid,
|
||||
int flags, void *data)
|
||||
{
|
||||
struct ref_filter *filter = (struct ref_filter *)data;
|
||||
|
||||
if (wildmatch(filter->pattern, refname, 0, NULL))
|
||||
return 0;
|
||||
return filter->fn(refname, sha1, flags, filter->cb_data);
|
||||
return filter->fn(refname, oid, flags, filter->cb_data);
|
||||
}
|
||||
|
||||
enum peel_status {
|
||||
|
|
@ -1836,9 +1837,9 @@ static enum peel_status peel_entry(struct ref_entry *entry, int repeel)
|
|||
if (entry->flag & REF_KNOWS_PEELED) {
|
||||
if (repeel) {
|
||||
entry->flag &= ~REF_KNOWS_PEELED;
|
||||
hashclr(entry->u.value.peeled);
|
||||
oidclr(&entry->u.value.peeled);
|
||||
} else {
|
||||
return is_null_sha1(entry->u.value.peeled) ?
|
||||
return is_null_oid(&entry->u.value.peeled) ?
|
||||
PEEL_NON_TAG : PEEL_PEELED;
|
||||
}
|
||||
}
|
||||
|
|
@ -1847,7 +1848,7 @@ static enum peel_status peel_entry(struct ref_entry *entry, int repeel)
|
|||
if (entry->flag & REF_ISSYMREF)
|
||||
return PEEL_IS_SYMREF;
|
||||
|
||||
status = peel_object(entry->u.value.sha1, entry->u.value.peeled);
|
||||
status = peel_object(entry->u.value.oid.hash, entry->u.value.peeled.hash);
|
||||
if (status == PEEL_PEELED || status == PEEL_NON_TAG)
|
||||
entry->flag |= REF_KNOWS_PEELED;
|
||||
return status;
|
||||
|
|
@ -1862,7 +1863,7 @@ int peel_ref(const char *refname, unsigned char *sha1)
|
|||
|| !strcmp(current_ref->name, refname))) {
|
||||
if (peel_entry(current_ref, 0))
|
||||
return -1;
|
||||
hashcpy(sha1, current_ref->u.value.peeled);
|
||||
hashcpy(sha1, current_ref->u.value.peeled.hash);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1882,7 +1883,7 @@ int peel_ref(const char *refname, unsigned char *sha1)
|
|||
if (r) {
|
||||
if (peel_entry(r, 0))
|
||||
return -1;
|
||||
hashcpy(sha1, r->u.value.peeled);
|
||||
hashcpy(sha1, r->u.value.peeled.hash);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -1897,17 +1898,17 @@ struct warn_if_dangling_data {
|
|||
const char *msg_fmt;
|
||||
};
|
||||
|
||||
static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,
|
||||
static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
struct warn_if_dangling_data *d = cb_data;
|
||||
const char *resolves_to;
|
||||
unsigned char junk[20];
|
||||
struct object_id junk;
|
||||
|
||||
if (!(flags & REF_ISSYMREF))
|
||||
return 0;
|
||||
|
||||
resolves_to = resolve_ref_unsafe(refname, 0, junk, NULL);
|
||||
resolves_to = resolve_ref_unsafe(refname, 0, junk.hash, NULL);
|
||||
if (!resolves_to
|
||||
|| (d->refname
|
||||
? strcmp(resolves_to, d->refname)
|
||||
|
|
@ -2027,18 +2028,18 @@ static int do_for_each_ref(struct ref_cache *refs, const char *base,
|
|||
|
||||
static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
unsigned char sha1[20];
|
||||
struct object_id oid;
|
||||
int flag;
|
||||
|
||||
if (submodule) {
|
||||
if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)
|
||||
return fn("HEAD", sha1, 0, cb_data);
|
||||
if (resolve_gitlink_ref(submodule, "HEAD", oid.hash) == 0)
|
||||
return fn("HEAD", &oid, 0, cb_data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!read_ref_full("HEAD", RESOLVE_REF_READING, sha1, &flag))
|
||||
return fn("HEAD", sha1, flag, cb_data);
|
||||
if (!read_ref_full("HEAD", RESOLVE_REF_READING, oid.hash, &flag))
|
||||
return fn("HEAD", &oid, flag, cb_data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -2113,12 +2114,12 @@ int head_ref_namespaced(each_ref_fn fn, void *cb_data)
|
|||
{
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
int ret = 0;
|
||||
unsigned char sha1[20];
|
||||
struct object_id oid;
|
||||
int flag;
|
||||
|
||||
strbuf_addf(&buf, "%sHEAD", get_git_namespace());
|
||||
if (!read_ref_full(buf.buf, RESOLVE_REF_READING, sha1, &flag))
|
||||
ret = fn(buf.buf, sha1, flag, cb_data);
|
||||
if (!read_ref_full(buf.buf, RESOLVE_REF_READING, oid.hash, &flag))
|
||||
ret = fn(buf.buf, &oid, flag, cb_data);
|
||||
strbuf_release(&buf);
|
||||
|
||||
return ret;
|
||||
|
|
@ -2224,16 +2225,16 @@ static struct ref_lock *verify_lock(struct ref_lock *lock,
|
|||
{
|
||||
if (read_ref_full(lock->ref_name,
|
||||
mustexist ? RESOLVE_REF_READING : 0,
|
||||
lock->old_sha1, NULL)) {
|
||||
lock->old_oid.hash, NULL)) {
|
||||
int save_errno = errno;
|
||||
error("Can't verify ref %s", lock->ref_name);
|
||||
unlock_ref(lock);
|
||||
errno = save_errno;
|
||||
return NULL;
|
||||
}
|
||||
if (hashcmp(lock->old_sha1, old_sha1)) {
|
||||
if (hashcmp(lock->old_oid.hash, old_sha1)) {
|
||||
error("Ref %s is at %s but expected %s", lock->ref_name,
|
||||
sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
|
||||
oid_to_hex(&lock->old_oid), sha1_to_hex(old_sha1));
|
||||
unlock_ref(lock);
|
||||
errno = EBUSY;
|
||||
return NULL;
|
||||
|
|
@ -2381,7 +2382,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname,
|
|||
}
|
||||
|
||||
refname = resolve_ref_unsafe(refname, resolve_flags,
|
||||
lock->old_sha1, &type);
|
||||
lock->old_oid.hash, &type);
|
||||
if (!refname && errno == EISDIR) {
|
||||
/* we are trying to lock foo but we used to
|
||||
* have foo/bar which now does not exist;
|
||||
|
|
@ -2400,7 +2401,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname,
|
|||
goto error_return;
|
||||
}
|
||||
refname = resolve_ref_unsafe(orig_refname, resolve_flags,
|
||||
lock->old_sha1, &type);
|
||||
lock->old_oid.hash, &type);
|
||||
}
|
||||
if (type_p)
|
||||
*type_p = type;
|
||||
|
|
@ -2420,7 +2421,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname,
|
|||
* refname, nor a packed ref whose name is a proper prefix of
|
||||
* our refname.
|
||||
*/
|
||||
if (is_null_sha1(lock->old_sha1) &&
|
||||
if (is_null_oid(&lock->old_oid) &&
|
||||
verify_refname_available(refname, extras, skip,
|
||||
get_packed_refs(&ref_cache), err)) {
|
||||
last_errno = ENOTDIR;
|
||||
|
|
@ -2496,9 +2497,9 @@ static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)
|
|||
if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
|
||||
error("internal error: %s is not a valid packed reference!",
|
||||
entry->name);
|
||||
write_packed_entry(cb_data, entry->name, entry->u.value.sha1,
|
||||
write_packed_entry(cb_data, entry->name, entry->u.value.oid.hash,
|
||||
peel_status == PEEL_PEELED ?
|
||||
entry->u.value.peeled : NULL);
|
||||
entry->u.value.peeled.hash : NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -2615,24 +2616,24 @@ static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)
|
|||
peel_status = peel_entry(entry, 1);
|
||||
if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
|
||||
die("internal error peeling reference %s (%s)",
|
||||
entry->name, sha1_to_hex(entry->u.value.sha1));
|
||||
entry->name, oid_to_hex(&entry->u.value.oid));
|
||||
packed_entry = find_ref(cb->packed_refs, entry->name);
|
||||
if (packed_entry) {
|
||||
/* Overwrite existing packed entry with info from loose entry */
|
||||
packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;
|
||||
hashcpy(packed_entry->u.value.sha1, entry->u.value.sha1);
|
||||
oidcpy(&packed_entry->u.value.oid, &entry->u.value.oid);
|
||||
} else {
|
||||
packed_entry = create_ref_entry(entry->name, entry->u.value.sha1,
|
||||
packed_entry = create_ref_entry(entry->name, entry->u.value.oid.hash,
|
||||
REF_ISPACKED | REF_KNOWS_PEELED, 0);
|
||||
add_ref(cb->packed_refs, packed_entry);
|
||||
}
|
||||
hashcpy(packed_entry->u.value.peeled, entry->u.value.peeled);
|
||||
oidcpy(&packed_entry->u.value.peeled, &entry->u.value.peeled);
|
||||
|
||||
/* Schedule the loose reference for pruning if requested. */
|
||||
if ((cb->flags & PACK_REFS_PRUNE)) {
|
||||
int namelen = strlen(entry->name) + 1;
|
||||
struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);
|
||||
hashcpy(n->sha1, entry->u.value.sha1);
|
||||
hashcpy(n->sha1, entry->u.value.oid.hash);
|
||||
strcpy(n->name, entry->name);
|
||||
n->next = cb->ref_to_prune;
|
||||
cb->ref_to_prune = n;
|
||||
|
|
@ -2943,7 +2944,7 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
|
|||
strbuf_release(&err);
|
||||
goto rollback;
|
||||
}
|
||||
hashcpy(lock->old_sha1, orig_sha1);
|
||||
hashcpy(lock->old_oid.hash, orig_sha1);
|
||||
|
||||
if (write_ref_to_lockfile(lock, orig_sha1) ||
|
||||
commit_ref_update(lock, orig_sha1, logmsg)) {
|
||||
|
|
@ -3198,9 +3199,9 @@ static int commit_ref_update(struct ref_lock *lock,
|
|||
const unsigned char *sha1, const char *logmsg)
|
||||
{
|
||||
clear_loose_ref_cache(&ref_cache);
|
||||
if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
|
||||
if (log_ref_write(lock->ref_name, lock->old_oid.hash, sha1, logmsg) < 0 ||
|
||||
(strcmp(lock->ref_name, lock->orig_ref_name) &&
|
||||
log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
|
||||
log_ref_write(lock->orig_ref_name, lock->old_oid.hash, sha1, logmsg) < 0)) {
|
||||
unlock_ref(lock);
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -3224,7 +3225,7 @@ static int commit_ref_update(struct ref_lock *lock,
|
|||
head_sha1, &head_flag);
|
||||
if (head_ref && (head_flag & REF_ISSYMREF) &&
|
||||
!strcmp(head_ref, lock->ref_name))
|
||||
log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
|
||||
log_ref_write("HEAD", lock->old_oid.hash, sha1, logmsg);
|
||||
}
|
||||
if (commit_ref(lock)) {
|
||||
error("Couldn't set %s", lock->ref_name);
|
||||
|
|
@ -3616,11 +3617,12 @@ static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data
|
|||
strbuf_addch(name, '/');
|
||||
retval = do_for_each_reflog(name, fn, cb_data);
|
||||
} else {
|
||||
unsigned char sha1[20];
|
||||
if (read_ref_full(name->buf, 0, sha1, NULL))
|
||||
struct object_id oid;
|
||||
|
||||
if (read_ref_full(name->buf, 0, oid.hash, NULL))
|
||||
retval = error("bad ref for %s", name->buf);
|
||||
else
|
||||
retval = fn(name->buf, sha1, 0, cb_data);
|
||||
retval = fn(name->buf, &oid, 0, cb_data);
|
||||
}
|
||||
if (retval)
|
||||
break;
|
||||
|
|
@ -3921,7 +3923,7 @@ int ref_transaction_commit(struct ref_transaction *transaction,
|
|||
(update->flags & REF_NODEREF));
|
||||
|
||||
if (!overwriting_symref &&
|
||||
!hashcmp(update->lock->old_sha1, update->new_sha1)) {
|
||||
!hashcmp(update->lock->old_oid.hash, update->new_sha1)) {
|
||||
/*
|
||||
* The reference already has the desired
|
||||
* value, so we don't need to write it.
|
||||
|
|
|
|||
2
refs.h
2
refs.h
|
|
@ -67,7 +67,7 @@ struct ref_transaction;
|
|||
* single callback invocation.
|
||||
*/
|
||||
typedef int each_ref_fn(const char *refname,
|
||||
const unsigned char *sha1, int flags, void *cb_data);
|
||||
const struct object_id *oid, int flags, void *cb_data);
|
||||
|
||||
/*
|
||||
* The following functions invoke the specified callback function for
|
||||
|
|
|
|||
13
remote.c
13
remote.c
|
|
@ -2168,7 +2168,8 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int one_local_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct ref ***local_tail = cb_data;
|
||||
struct ref *ref;
|
||||
|
|
@ -2180,7 +2181,7 @@ static int one_local_ref(const char *refname, const unsigned char *sha1, int fla
|
|||
|
||||
len = strlen(refname) + 1;
|
||||
ref = xcalloc(1, sizeof(*ref) + len);
|
||||
hashcpy(ref->new_sha1, sha1);
|
||||
hashcpy(ref->new_sha1, oid->hash);
|
||||
memcpy(ref->name, refname, len);
|
||||
**local_tail = ref;
|
||||
*local_tail = &ref->next;
|
||||
|
|
@ -2190,6 +2191,7 @@ static int one_local_ref(const char *refname, const unsigned char *sha1, int fla
|
|||
struct ref *get_local_heads(void)
|
||||
{
|
||||
struct ref *local_refs = NULL, **local_tail = &local_refs;
|
||||
|
||||
for_each_ref(one_local_ref, &local_tail);
|
||||
return local_refs;
|
||||
}
|
||||
|
|
@ -2242,8 +2244,8 @@ struct stale_heads_info {
|
|||
int ref_count;
|
||||
};
|
||||
|
||||
static int get_stale_heads_cb(const char *refname,
|
||||
const unsigned char *sha1, int flags, void *cb_data)
|
||||
static int get_stale_heads_cb(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
struct stale_heads_info *info = cb_data;
|
||||
struct string_list matches = STRING_LIST_INIT_DUP;
|
||||
|
|
@ -2272,7 +2274,7 @@ static int get_stale_heads_cb(const char *refname,
|
|||
|
||||
if (stale) {
|
||||
struct ref *ref = make_linked_ref(refname, &info->stale_refs_tail);
|
||||
hashcpy(ref->new_sha1, sha1);
|
||||
hashcpy(ref->new_sha1, oid->hash);
|
||||
}
|
||||
|
||||
clean_exit:
|
||||
|
|
@ -2285,6 +2287,7 @@ struct ref *get_stale_heads(struct refspec *refs, int ref_count, struct ref *fet
|
|||
struct ref *ref, *stale_refs = NULL;
|
||||
struct string_list ref_names = STRING_LIST_INIT_NODUP;
|
||||
struct stale_heads_info info;
|
||||
|
||||
info.ref_names = &ref_names;
|
||||
info.stale_refs_tail = &stale_refs;
|
||||
info.refs = refs;
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ static int register_replace_object(struct replace_object *replace,
|
|||
}
|
||||
|
||||
static int register_replace_ref(const char *refname,
|
||||
const unsigned char *sha1,
|
||||
const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
/* Get sha1 from refname */
|
||||
|
|
@ -68,7 +68,7 @@ static int register_replace_ref(const char *refname,
|
|||
}
|
||||
|
||||
/* Copy sha1 from the read ref */
|
||||
hashcpy(repl_obj->replacement, sha1);
|
||||
hashcpy(repl_obj->replacement, oid->hash);
|
||||
|
||||
/* Register new object */
|
||||
if (register_replace_object(repl_obj, 1))
|
||||
|
|
|
|||
11
revision.c
11
revision.c
|
|
@ -1218,7 +1218,8 @@ int ref_excluded(struct string_list *ref_excludes, const char *path)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int handle_one_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int handle_one_ref(const char *path, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct all_refs_cb *cb = cb_data;
|
||||
struct object *object;
|
||||
|
|
@ -1226,9 +1227,9 @@ static int handle_one_ref(const char *path, const unsigned char *sha1, int flag,
|
|||
if (ref_excluded(cb->all_revs->ref_excludes, path))
|
||||
return 0;
|
||||
|
||||
object = get_reference(cb->all_revs, path, sha1, cb->all_flags);
|
||||
object = get_reference(cb->all_revs, path, oid->hash, cb->all_flags);
|
||||
add_rev_cmdline(cb->all_revs, object, path, REV_CMD_REF, cb->all_flags);
|
||||
add_pending_sha1(cb->all_revs, path, sha1, cb->all_flags);
|
||||
add_pending_sha1(cb->all_revs, path, oid->hash, cb->all_flags);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1292,7 +1293,8 @@ static int handle_one_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int handle_one_reflog(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int handle_one_reflog(const char *path, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct all_refs_cb *cb = cb_data;
|
||||
cb->warned_bad_reflog = 0;
|
||||
|
|
@ -1304,6 +1306,7 @@ static int handle_one_reflog(const char *path, const unsigned char *sha1, int fl
|
|||
void add_reflogs_to_pending(struct rev_info *revs, unsigned flags)
|
||||
{
|
||||
struct all_refs_cb cb;
|
||||
|
||||
cb.all_revs = revs;
|
||||
cb.all_flags = flags;
|
||||
for_each_reflog(handle_one_reflog, &cb);
|
||||
|
|
|
|||
|
|
@ -47,14 +47,15 @@ out:
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int add_info_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int add_info_ref(const char *path, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
FILE *fp = cb_data;
|
||||
struct object *o = parse_object(sha1);
|
||||
struct object *o = parse_object(oid->hash);
|
||||
if (!o)
|
||||
return -1;
|
||||
|
||||
if (fprintf(fp, "%s %s\n", sha1_to_hex(sha1), path) < 0)
|
||||
if (fprintf(fp, "%s %s\n", oid_to_hex(oid), path) < 0)
|
||||
return -1;
|
||||
|
||||
if (o->type == OBJ_TAG) {
|
||||
|
|
|
|||
|
|
@ -845,11 +845,11 @@ static int get_sha1_1(const char *name, int len, unsigned char *sha1, unsigned l
|
|||
/* Remember to update object flag allocation in object.h */
|
||||
#define ONELINE_SEEN (1u<<20)
|
||||
|
||||
static int handle_one_ref(const char *path,
|
||||
const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int handle_one_ref(const char *path, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct commit_list **list = cb_data;
|
||||
struct object *object = parse_object(sha1);
|
||||
struct object *object = parse_object(oid->hash);
|
||||
if (!object)
|
||||
return 0;
|
||||
if (object->type == OBJ_TAG) {
|
||||
|
|
@ -1379,6 +1379,7 @@ static int get_sha1_with_context_1(const char *name,
|
|||
int pos;
|
||||
if (!only_to_die && namelen > 2 && name[1] == '/') {
|
||||
struct commit_list *list = NULL;
|
||||
|
||||
for_each_ref(handle_one_ref, &list);
|
||||
commit_list_sort_by_date(&list);
|
||||
return get_sha1_oneline(name + 2, sha1, list);
|
||||
|
|
|
|||
12
shallow.c
12
shallow.c
|
|
@ -475,11 +475,10 @@ static void paint_down(struct paint_info *info, const unsigned char *sha1,
|
|||
free(tmp);
|
||||
}
|
||||
|
||||
static int mark_uninteresting(const char *refname,
|
||||
const unsigned char *sha1,
|
||||
static int mark_uninteresting(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
struct commit *commit = lookup_commit_reference_gently(sha1, 1);
|
||||
struct commit *commit = lookup_commit_reference_gently(oid->hash, 1);
|
||||
if (!commit)
|
||||
return 0;
|
||||
commit->object.flags |= UNINTERESTING;
|
||||
|
|
@ -584,12 +583,12 @@ struct commit_array {
|
|||
int nr, alloc;
|
||||
};
|
||||
|
||||
static int add_ref(const char *refname,
|
||||
const unsigned char *sha1, int flags, void *cb_data)
|
||||
static int add_ref(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
struct commit_array *ca = cb_data;
|
||||
ALLOC_GROW(ca->commits, ca->nr + 1, ca->alloc);
|
||||
ca->commits[ca->nr] = lookup_commit_reference_gently(sha1, 1);
|
||||
ca->commits[ca->nr] = lookup_commit_reference_gently(oid->hash, 1);
|
||||
if (ca->commits[ca->nr])
|
||||
ca->nr++;
|
||||
return 0;
|
||||
|
|
@ -674,6 +673,7 @@ int delayed_reachability_test(struct shallow_info *si, int c)
|
|||
|
||||
if (!si->commits) {
|
||||
struct commit_array ca;
|
||||
|
||||
memset(&ca, 0, sizeof(ca));
|
||||
head_ref(add_ref, &ca);
|
||||
for_each_ref(add_ref, &ca);
|
||||
|
|
|
|||
|
|
@ -422,7 +422,8 @@ void set_config_fetch_recurse_submodules(int value)
|
|||
config_fetch_recurse_submodules = value;
|
||||
}
|
||||
|
||||
static int has_remote(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
|
||||
static int has_remote(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -616,10 +617,10 @@ static void submodule_collect_changed_cb(struct diff_queue_struct *q,
|
|||
}
|
||||
}
|
||||
|
||||
static int add_sha1_to_array(const char *ref, const unsigned char *sha1,
|
||||
static int add_sha1_to_array(const char *ref, const struct object_id *oid,
|
||||
int flags, void *data)
|
||||
{
|
||||
sha1_array_append(data, sha1);
|
||||
sha1_array_append(data, oid->hash);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
14
transport.c
14
transport.c
|
|
@ -278,8 +278,8 @@ static int fetch_objs_via_rsync(struct transport *transport,
|
|||
return run_command(&rsync);
|
||||
}
|
||||
|
||||
static int write_one_ref(const char *name, const unsigned char *sha1,
|
||||
int flags, void *data)
|
||||
static int write_one_ref(const char *name, const struct object_id *oid,
|
||||
int flags, void *data)
|
||||
{
|
||||
struct strbuf *buf = data;
|
||||
int len = buf->len;
|
||||
|
|
@ -291,7 +291,7 @@ static int write_one_ref(const char *name, const unsigned char *sha1,
|
|||
|
||||
strbuf_addstr(buf, name);
|
||||
if (safe_create_leading_directories(buf->buf) ||
|
||||
write_file(buf->buf, 0, "%s\n", sha1_to_hex(sha1)))
|
||||
write_file(buf->buf, 0, "%s\n", oid_to_hex(oid)))
|
||||
return error("problems writing temporary file %s: %s",
|
||||
buf->buf, strerror(errno));
|
||||
strbuf_setlen(buf, len);
|
||||
|
|
@ -299,18 +299,18 @@ static int write_one_ref(const char *name, const unsigned char *sha1,
|
|||
}
|
||||
|
||||
static int write_refs_to_temp_dir(struct strbuf *temp_dir,
|
||||
int refspec_nr, const char **refspec)
|
||||
int refspec_nr, const char **refspec)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < refspec_nr; i++) {
|
||||
unsigned char sha1[20];
|
||||
struct object_id oid;
|
||||
char *ref;
|
||||
|
||||
if (dwim_ref(refspec[i], strlen(refspec[i]), sha1, &ref) != 1)
|
||||
if (dwim_ref(refspec[i], strlen(refspec[i]), oid.hash, &ref) != 1)
|
||||
return error("Could not get ref %s", refspec[i]);
|
||||
|
||||
if (write_one_ref(ref, sha1, 0, temp_dir)) {
|
||||
if (write_one_ref(ref, &oid, 0, temp_dir)) {
|
||||
free(ref);
|
||||
return -1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -690,9 +690,9 @@ static void receive_needs(void)
|
|||
}
|
||||
|
||||
/* return non-zero if the ref is hidden, otherwise 0 */
|
||||
static int mark_our_ref(const char *refname, const unsigned char *sha1)
|
||||
static int mark_our_ref(const char *refname, const struct object_id *oid)
|
||||
{
|
||||
struct object *o = lookup_unknown_object(sha1);
|
||||
struct object *o = lookup_unknown_object(oid->hash);
|
||||
|
||||
if (ref_is_hidden(refname)) {
|
||||
o->flags |= HIDDEN_REF;
|
||||
|
|
@ -702,9 +702,10 @@ static int mark_our_ref(const char *refname, const unsigned char *sha1)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int check_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int check_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
mark_our_ref(refname, sha1);
|
||||
mark_our_ref(refname, oid);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -718,15 +719,16 @@ static void format_symref_info(struct strbuf *buf, struct string_list *symref)
|
|||
strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
|
||||
}
|
||||
|
||||
static int send_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int send_ref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
static const char *capabilities = "multi_ack thin-pack side-band"
|
||||
" side-band-64k ofs-delta shallow no-progress"
|
||||
" include-tag multi_ack_detailed";
|
||||
const char *refname_nons = strip_namespace(refname);
|
||||
unsigned char peeled[20];
|
||||
struct object_id peeled;
|
||||
|
||||
if (mark_our_ref(refname, sha1))
|
||||
if (mark_our_ref(refname, oid))
|
||||
return 0;
|
||||
|
||||
if (capabilities) {
|
||||
|
|
@ -734,7 +736,7 @@ static int send_ref(const char *refname, const unsigned char *sha1, int flag, vo
|
|||
|
||||
format_symref_info(&symref_info, cb_data);
|
||||
packet_write(1, "%s %s%c%s%s%s%s%s agent=%s\n",
|
||||
sha1_to_hex(sha1), refname_nons,
|
||||
oid_to_hex(oid), refname_nons,
|
||||
0, capabilities,
|
||||
(allow_unadvertised_object_request & ALLOW_TIP_SHA1) ?
|
||||
" allow-tip-sha1-in-want" : "",
|
||||
|
|
@ -745,24 +747,24 @@ static int send_ref(const char *refname, const unsigned char *sha1, int flag, vo
|
|||
git_user_agent_sanitized());
|
||||
strbuf_release(&symref_info);
|
||||
} else {
|
||||
packet_write(1, "%s %s\n", sha1_to_hex(sha1), refname_nons);
|
||||
packet_write(1, "%s %s\n", oid_to_hex(oid), refname_nons);
|
||||
}
|
||||
capabilities = NULL;
|
||||
if (!peel_ref(refname, peeled))
|
||||
packet_write(1, "%s %s^{}\n", sha1_to_hex(peeled), refname_nons);
|
||||
if (!peel_ref(refname, peeled.hash))
|
||||
packet_write(1, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int find_symref(const char *refname, const unsigned char *sha1, int flag,
|
||||
void *cb_data)
|
||||
static int find_symref(const char *refname, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
const char *symref_target;
|
||||
struct string_list_item *item;
|
||||
unsigned char unused[20];
|
||||
struct object_id unused;
|
||||
|
||||
if ((flag & REF_ISSYMREF) == 0)
|
||||
return 0;
|
||||
symref_target = resolve_ref_unsafe(refname, 0, unused, &flag);
|
||||
symref_target = resolve_ref_unsafe(refname, 0, unused.hash, &flag);
|
||||
if (!symref_target || (flag & REF_ISSYMREF) == 0)
|
||||
die("'%s' is a symref but it is not?", refname);
|
||||
item = string_list_append(cb_data, refname);
|
||||
|
|
|
|||
6
walker.c
6
walker.c
|
|
@ -200,9 +200,11 @@ static int interpret_target(struct walker *walker, char *target, unsigned char *
|
|||
return -1;
|
||||
}
|
||||
|
||||
static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
||||
static int mark_complete(const char *path, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct commit *commit = lookup_commit_reference_gently(sha1, 1);
|
||||
struct commit *commit = lookup_commit_reference_gently(oid->hash, 1);
|
||||
|
||||
if (commit) {
|
||||
commit->object.flags |= COMPLETE;
|
||||
commit_list_insert(commit, &complete);
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче