зеркало из https://github.com/microsoft/git.git
Merge branch 'sb/object-store-lookup'
lookup_commit_reference() and friends have been updated to find in-core object for a specific in-core repository instance. * sb/object-store-lookup: (32 commits) commit.c: allow lookup_commit_reference to handle arbitrary repositories commit.c: allow lookup_commit_reference_gently to handle arbitrary repositories tag.c: allow deref_tag to handle arbitrary repositories object.c: allow parse_object to handle arbitrary repositories object.c: allow parse_object_buffer to handle arbitrary repositories commit.c: allow get_cached_commit_buffer to handle arbitrary repositories commit.c: allow set_commit_buffer to handle arbitrary repositories commit.c: migrate the commit buffer to the parsed object store commit-slabs: remove realloc counter outside of slab struct commit.c: allow parse_commit_buffer to handle arbitrary repositories tag: allow parse_tag_buffer to handle arbitrary repositories tag: allow lookup_tag to handle arbitrary repositories commit: allow lookup_commit to handle arbitrary repositories tree: allow lookup_tree to handle arbitrary repositories blob: allow lookup_blob to handle arbitrary repositories object: allow lookup_object to handle arbitrary repositories object: allow object_as_type to handle arbitrary repositories tag: add repository argument to deref_tag tag: add repository argument to parse_tag_buffer tag: add repository argument to lookup_tag ...
This commit is contained in:
Коммит
3a2a1dc170
|
@ -380,7 +380,7 @@ static void parse_treeish_arg(const char **argv,
|
|||
if (get_oid(name, &oid))
|
||||
die("Not a valid object name");
|
||||
|
||||
commit = lookup_commit_reference_gently(&oid, 1);
|
||||
commit = lookup_commit_reference_gently(the_repository, &oid, 1);
|
||||
if (commit) {
|
||||
commit_sha1 = commit->object.oid.hash;
|
||||
archive_time = commit->date;
|
||||
|
|
2
bisect.c
2
bisect.c
|
@ -724,7 +724,7 @@ static int bisect_checkout(const struct object_id *bisect_rev, int no_checkout)
|
|||
|
||||
static struct commit *get_commit_reference(const struct object_id *oid)
|
||||
{
|
||||
struct commit *r = lookup_commit_reference(oid);
|
||||
struct commit *r = lookup_commit_reference(the_repository, oid);
|
||||
if (!r)
|
||||
die(_("Not a valid commit name %s"), oid_to_hex(oid));
|
||||
return r;
|
||||
|
|
13
blame.c
13
blame.c
|
@ -119,7 +119,7 @@ static struct commit_list **append_parent(struct commit_list **tail, const struc
|
|||
{
|
||||
struct commit *parent;
|
||||
|
||||
parent = lookup_commit_reference(oid);
|
||||
parent = lookup_commit_reference(the_repository, oid);
|
||||
if (!parent)
|
||||
die("no such commit %s", oid_to_hex(oid));
|
||||
return &commit_list_insert(parent, tail)->next;
|
||||
|
@ -158,7 +158,7 @@ static void set_commit_buffer_from_strbuf(struct commit *c, struct strbuf *sb)
|
|||
{
|
||||
size_t len;
|
||||
void *buf = strbuf_detach(sb, &len);
|
||||
set_commit_buffer(c, buf, len);
|
||||
set_commit_buffer(the_repository, c, buf, len);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -1674,7 +1674,7 @@ static struct commit *find_single_final(struct rev_info *revs,
|
|||
struct object *obj = revs->pending.objects[i].item;
|
||||
if (obj->flags & UNINTERESTING)
|
||||
continue;
|
||||
obj = deref_tag(obj, NULL, 0);
|
||||
obj = deref_tag(the_repository, obj, NULL, 0);
|
||||
if (obj->type != OBJ_COMMIT)
|
||||
die("Non commit %s?", revs->pending.objects[i].name);
|
||||
if (found)
|
||||
|
@ -1705,14 +1705,15 @@ static struct commit *dwim_reverse_initial(struct rev_info *revs,
|
|||
|
||||
/* Is that sole rev a committish? */
|
||||
obj = revs->pending.objects[0].item;
|
||||
obj = deref_tag(obj, NULL, 0);
|
||||
obj = deref_tag(the_repository, obj, NULL, 0);
|
||||
if (obj->type != OBJ_COMMIT)
|
||||
return NULL;
|
||||
|
||||
/* Do we have HEAD? */
|
||||
if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
|
||||
return NULL;
|
||||
head_commit = lookup_commit_reference_gently(&head_oid, 1);
|
||||
head_commit = lookup_commit_reference_gently(the_repository,
|
||||
&head_oid, 1);
|
||||
if (!head_commit)
|
||||
return NULL;
|
||||
|
||||
|
@ -1740,7 +1741,7 @@ static struct commit *find_single_initial(struct rev_info *revs,
|
|||
struct object *obj = revs->pending.objects[i].item;
|
||||
if (!(obj->flags & UNINTERESTING))
|
||||
continue;
|
||||
obj = deref_tag(obj, NULL, 0);
|
||||
obj = deref_tag(the_repository, obj, NULL, 0);
|
||||
if (obj->type != OBJ_COMMIT)
|
||||
die("Non commit %s?", revs->pending.objects[i].name);
|
||||
if (found)
|
||||
|
|
10
blob.c
10
blob.c
|
@ -5,13 +5,13 @@
|
|||
|
||||
const char *blob_type = "blob";
|
||||
|
||||
struct blob *lookup_blob(const struct object_id *oid)
|
||||
struct blob *lookup_blob(struct repository *r, const struct object_id *oid)
|
||||
{
|
||||
struct object *obj = lookup_object(oid->hash);
|
||||
struct object *obj = lookup_object(r, oid->hash);
|
||||
if (!obj)
|
||||
return create_object(the_repository, oid->hash,
|
||||
alloc_blob_node(the_repository));
|
||||
return object_as_type(obj, OBJ_BLOB, 0);
|
||||
return create_object(r, oid->hash,
|
||||
alloc_blob_node(r));
|
||||
return object_as_type(r, obj, OBJ_BLOB, 0);
|
||||
}
|
||||
|
||||
int parse_blob_buffer(struct blob *item, void *buffer, unsigned long size)
|
||||
|
|
2
blob.h
2
blob.h
|
@ -9,7 +9,7 @@ struct blob {
|
|||
struct object object;
|
||||
};
|
||||
|
||||
struct blob *lookup_blob(const struct object_id *oid);
|
||||
struct blob *lookup_blob(struct repository *r, const struct object_id *oid);
|
||||
|
||||
int parse_blob_buffer(struct blob *item, void *buffer, unsigned long size);
|
||||
|
||||
|
|
2
branch.c
2
branch.c
|
@ -302,7 +302,7 @@ void create_branch(const char *name, const char *start_name,
|
|||
break;
|
||||
}
|
||||
|
||||
if ((commit = lookup_commit_reference(&oid)) == NULL)
|
||||
if ((commit = lookup_commit_reference(the_repository, &oid)) == NULL)
|
||||
die(_("Not a valid branch point: '%s'."), start_name);
|
||||
oidcpy(&oid, &commit->object.oid);
|
||||
|
||||
|
|
|
@ -32,6 +32,7 @@
|
|||
#include "apply.h"
|
||||
#include "string-list.h"
|
||||
#include "packfile.h"
|
||||
#include "repository.h"
|
||||
|
||||
/**
|
||||
* Returns 1 if the file is empty or does not exist, 0 otherwise.
|
||||
|
@ -1400,9 +1401,10 @@ static void write_index_patch(const struct am_state *state)
|
|||
FILE *fp;
|
||||
|
||||
if (!get_oid_tree("HEAD", &head))
|
||||
tree = lookup_tree(&head);
|
||||
tree = lookup_tree(the_repository, &head);
|
||||
else
|
||||
tree = lookup_tree(the_hash_algo->empty_tree);
|
||||
tree = lookup_tree(the_repository,
|
||||
the_repository->hash_algo->empty_tree);
|
||||
|
||||
fp = xfopen(am_path(state, "patch"), "w");
|
||||
init_revisions(&rev_info, NULL);
|
||||
|
@ -1631,7 +1633,8 @@ static void do_commit(const struct am_state *state)
|
|||
|
||||
if (!get_oid_commit("HEAD", &parent)) {
|
||||
old_oid = &parent;
|
||||
commit_list_insert(lookup_commit(&parent), &parents);
|
||||
commit_list_insert(lookup_commit(the_repository, &parent),
|
||||
&parents);
|
||||
} else {
|
||||
old_oid = NULL;
|
||||
say(state, stderr, _("applying to an empty history"));
|
||||
|
|
|
@ -122,7 +122,8 @@ static int branch_merged(int kind, const char *name,
|
|||
(reference_name = reference_name_to_free =
|
||||
resolve_refdup(upstream, RESOLVE_REF_READING,
|
||||
&oid, NULL)) != NULL)
|
||||
reference_rev = lookup_commit_reference(&oid);
|
||||
reference_rev = lookup_commit_reference(the_repository,
|
||||
&oid);
|
||||
}
|
||||
if (!reference_rev)
|
||||
reference_rev = head_rev;
|
||||
|
@ -155,7 +156,7 @@ static int check_branch_commit(const char *branchname, const char *refname,
|
|||
const struct object_id *oid, struct commit *head_rev,
|
||||
int kinds, int force)
|
||||
{
|
||||
struct commit *rev = lookup_commit_reference(oid);
|
||||
struct commit *rev = lookup_commit_reference(the_repository, oid);
|
||||
if (!rev) {
|
||||
error(_("Couldn't look up commit object for '%s'"), refname);
|
||||
return -1;
|
||||
|
@ -209,7 +210,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
|
|||
}
|
||||
|
||||
if (!force) {
|
||||
head_rev = lookup_commit_reference(&head_oid);
|
||||
head_rev = lookup_commit_reference(the_repository, &head_oid);
|
||||
if (!head_rev)
|
||||
die(_("Couldn't look up commit object for HEAD"));
|
||||
}
|
||||
|
|
|
@ -380,7 +380,7 @@ static int checkout_paths(const struct checkout_opts *opts,
|
|||
die(_("unable to write new index file"));
|
||||
|
||||
read_ref_full("HEAD", 0, &rev, NULL);
|
||||
head = lookup_commit_reference_gently(&rev, 1);
|
||||
head = lookup_commit_reference_gently(the_repository, &rev, 1);
|
||||
|
||||
errs |= post_checkout_hook(head, head, 0);
|
||||
return errs;
|
||||
|
@ -831,7 +831,7 @@ static int switch_branches(const struct checkout_opts *opts,
|
|||
memset(&old_branch_info, 0, sizeof(old_branch_info));
|
||||
old_branch_info.path = path_to_free = resolve_refdup("HEAD", 0, &rev, &flag);
|
||||
if (old_branch_info.path)
|
||||
old_branch_info.commit = lookup_commit_reference_gently(&rev, 1);
|
||||
old_branch_info.commit = lookup_commit_reference_gently(the_repository, &rev, 1);
|
||||
if (!(flag & REF_ISSYMREF))
|
||||
old_branch_info.path = NULL;
|
||||
|
||||
|
@ -1009,7 +1009,7 @@ static int parse_branchname_arg(int argc, const char **argv,
|
|||
else
|
||||
new_branch_info->path = NULL; /* not an existing branch */
|
||||
|
||||
new_branch_info->commit = lookup_commit_reference_gently(rev, 1);
|
||||
new_branch_info->commit = lookup_commit_reference_gently(the_repository, rev, 1);
|
||||
if (!new_branch_info->commit) {
|
||||
/* not a commit */
|
||||
*source_tree = parse_tree_indirect(rev);
|
||||
|
|
|
@ -696,7 +696,8 @@ static void update_head(const struct ref *our, const struct ref *remote,
|
|||
install_branch_config(0, head, option_origin, our->name);
|
||||
}
|
||||
} else if (our) {
|
||||
struct commit *c = lookup_commit_reference(&our->old_oid);
|
||||
struct commit *c = lookup_commit_reference(the_repository,
|
||||
&our->old_oid);
|
||||
/* --branch specifies a non-branch (i.e. tags), detach HEAD */
|
||||
update_ref(msg, "HEAD", &c->object.oid, NULL, REF_NO_DEREF,
|
||||
UPDATE_REFS_DIE_ON_ERR);
|
||||
|
|
|
@ -6,6 +6,7 @@
|
|||
#include "cache.h"
|
||||
#include "config.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "commit.h"
|
||||
#include "tree.h"
|
||||
#include "builtin.h"
|
||||
|
@ -60,7 +61,8 @@ int cmd_commit_tree(int argc, const char **argv, const char *prefix)
|
|||
if (get_oid_commit(argv[i], &oid))
|
||||
die("Not a valid object name %s", argv[i]);
|
||||
assert_oid_type(&oid, OBJ_COMMIT);
|
||||
new_parent(lookup_commit(&oid), &parents);
|
||||
new_parent(lookup_commit(the_repository, &oid),
|
||||
&parents);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
|
@ -93,13 +93,13 @@ static int replace_name(struct commit_name *e,
|
|||
struct tag *t;
|
||||
|
||||
if (!e->tag) {
|
||||
t = lookup_tag(&e->oid);
|
||||
t = lookup_tag(the_repository, &e->oid);
|
||||
if (!t || parse_tag(t))
|
||||
return 1;
|
||||
e->tag = t;
|
||||
}
|
||||
|
||||
t = lookup_tag(oid);
|
||||
t = lookup_tag(the_repository, oid);
|
||||
if (!t || parse_tag(t))
|
||||
return 0;
|
||||
*tag = t;
|
||||
|
@ -267,7 +267,7 @@ static unsigned long finish_depth_computation(
|
|||
static void append_name(struct commit_name *n, struct strbuf *dst)
|
||||
{
|
||||
if (n->prio == 2 && !n->tag) {
|
||||
n->tag = lookup_tag(&n->oid);
|
||||
n->tag = lookup_tag(the_repository, &n->oid);
|
||||
if (!n->tag || parse_tag(n->tag))
|
||||
die(_("annotated tag %s not available"), n->path);
|
||||
}
|
||||
|
@ -303,7 +303,7 @@ static void describe_commit(struct object_id *oid, struct strbuf *dst)
|
|||
unsigned long seen_commits = 0;
|
||||
unsigned int unannotated_cnt = 0;
|
||||
|
||||
cmit = lookup_commit_reference(oid);
|
||||
cmit = lookup_commit_reference(the_repository, oid);
|
||||
|
||||
n = find_commit_name(&cmit->object.oid);
|
||||
if (n && (tags || all || n->prio == 2)) {
|
||||
|
@ -331,7 +331,8 @@ static void describe_commit(struct object_id *oid, struct strbuf *dst)
|
|||
init_commit_names(&commit_names);
|
||||
n = hashmap_iter_first(&names, &iter);
|
||||
for (; n; n = hashmap_iter_next(&iter)) {
|
||||
c = lookup_commit_reference_gently(&n->peeled, 1);
|
||||
c = lookup_commit_reference_gently(the_repository,
|
||||
&n->peeled, 1);
|
||||
if (c)
|
||||
*commit_names_at(&commit_names, c) = n;
|
||||
}
|
||||
|
@ -509,7 +510,7 @@ static void describe(const char *arg, int last_one)
|
|||
|
||||
if (get_oid(arg, &oid))
|
||||
die(_("Not a valid object name %s"), arg);
|
||||
cmit = lookup_commit_reference_gently(&oid, 1);
|
||||
cmit = lookup_commit_reference_gently(the_repository, &oid, 1);
|
||||
|
||||
if (cmit)
|
||||
describe_commit(&oid, &sb);
|
||||
|
|
|
@ -5,12 +5,13 @@
|
|||
#include "log-tree.h"
|
||||
#include "builtin.h"
|
||||
#include "submodule.h"
|
||||
#include "repository.h"
|
||||
|
||||
static struct rev_info log_tree_opt;
|
||||
|
||||
static int diff_tree_commit_oid(const struct object_id *oid)
|
||||
{
|
||||
struct commit *commit = lookup_commit_reference(oid);
|
||||
struct commit *commit = lookup_commit_reference(the_repository, oid);
|
||||
if (!commit)
|
||||
return -1;
|
||||
return log_tree_commit(&log_tree_opt, commit);
|
||||
|
@ -24,7 +25,7 @@ static int stdin_diff_commit(struct commit *commit, const char *p)
|
|||
|
||||
/* Graft the fake parents locally to the commit */
|
||||
while (isspace(*p++) && !parse_oid_hex(p, &oid, &p)) {
|
||||
struct commit *parent = lookup_commit(&oid);
|
||||
struct commit *parent = lookup_commit(the_repository, &oid);
|
||||
if (!pptr) {
|
||||
/* Free the real parent list */
|
||||
free_commit_list(commit->parents);
|
||||
|
@ -45,7 +46,7 @@ static int stdin_diff_trees(struct tree *tree1, const char *p)
|
|||
struct tree *tree2;
|
||||
if (!isspace(*p++) || parse_oid_hex(p, &oid, &p) || *p)
|
||||
return error("Need exactly two trees, separated by a space");
|
||||
tree2 = lookup_tree(&oid);
|
||||
tree2 = lookup_tree(the_repository, &oid);
|
||||
if (!tree2 || parse_tree(tree2))
|
||||
return -1;
|
||||
printf("%s %s\n", oid_to_hex(&tree1->object.oid),
|
||||
|
@ -68,7 +69,7 @@ static int diff_tree_stdin(char *line)
|
|||
line[len-1] = 0;
|
||||
if (parse_oid_hex(line, &oid, &p))
|
||||
return -1;
|
||||
obj = parse_object(&oid);
|
||||
obj = parse_object(the_repository, &oid);
|
||||
if (!obj)
|
||||
return -1;
|
||||
if (obj->type == OBJ_COMMIT)
|
||||
|
|
|
@ -386,7 +386,8 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
|
|||
add_head_to_pending(&rev);
|
||||
if (!rev.pending.nr) {
|
||||
struct tree *tree;
|
||||
tree = lookup_tree(the_hash_algo->empty_tree);
|
||||
tree = lookup_tree(the_repository,
|
||||
the_repository->hash_algo->empty_tree);
|
||||
add_pending_object(&rev, &tree->object, "HEAD");
|
||||
}
|
||||
break;
|
||||
|
@ -400,8 +401,8 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
|
|||
const char *name = entry->name;
|
||||
int flags = (obj->flags & UNINTERESTING);
|
||||
if (!obj->parsed)
|
||||
obj = parse_object(&obj->oid);
|
||||
obj = deref_tag(obj, NULL, 0);
|
||||
obj = parse_object(the_repository, &obj->oid);
|
||||
obj = deref_tag(the_repository, obj, NULL, 0);
|
||||
if (!obj)
|
||||
die(_("invalid object '%s' given."), name);
|
||||
if (obj->type == OBJ_COMMIT)
|
||||
|
|
|
@ -230,13 +230,13 @@ static void export_blob(const struct object_id *oid)
|
|||
if (is_null_oid(oid))
|
||||
return;
|
||||
|
||||
object = lookup_object(oid->hash);
|
||||
object = lookup_object(the_repository, oid->hash);
|
||||
if (object && object->flags & SHOWN)
|
||||
return;
|
||||
|
||||
if (anonymize) {
|
||||
buf = anonymize_blob(&size);
|
||||
object = (struct object *)lookup_blob(oid);
|
||||
object = (struct object *)lookup_blob(the_repository, oid);
|
||||
eaten = 0;
|
||||
} else {
|
||||
buf = read_object_file(oid, &type, &size);
|
||||
|
@ -244,7 +244,8 @@ static void export_blob(const struct object_id *oid)
|
|||
die ("Could not read blob %s", oid_to_hex(oid));
|
||||
if (check_object_signature(oid, buf, size, type_name(type)) < 0)
|
||||
die("sha1 mismatch in blob %s", oid_to_hex(oid));
|
||||
object = parse_object_buffer(oid, type, size, buf, &eaten);
|
||||
object = parse_object_buffer(the_repository, oid, type,
|
||||
size, buf, &eaten);
|
||||
}
|
||||
|
||||
if (!object)
|
||||
|
@ -402,7 +403,8 @@ static void show_filemodify(struct diff_queue_struct *q,
|
|||
anonymize_sha1(&spec->oid) :
|
||||
spec->oid.hash));
|
||||
else {
|
||||
struct object *object = lookup_object(spec->oid.hash);
|
||||
struct object *object = lookup_object(the_repository,
|
||||
spec->oid.hash);
|
||||
printf("M %06o :%d ", spec->mode,
|
||||
get_object_mark(object));
|
||||
}
|
||||
|
@ -801,7 +803,7 @@ static struct commit *get_commit(struct rev_cmdline_entry *e, char *full_name)
|
|||
|
||||
/* handle nested tags */
|
||||
while (tag && tag->object.type == OBJ_TAG) {
|
||||
parse_object(&tag->object.oid);
|
||||
parse_object(the_repository, &tag->object.oid);
|
||||
string_list_append(&extra_refs, full_name)->util = tag;
|
||||
tag = (struct tag *)tag->tagged;
|
||||
}
|
||||
|
@ -961,7 +963,7 @@ static void import_marks(char *input_file)
|
|||
/* only commits */
|
||||
continue;
|
||||
|
||||
commit = lookup_commit(&oid);
|
||||
commit = lookup_commit(the_repository, &oid);
|
||||
if (!commit)
|
||||
die("not a commit? can't happen: %s", oid_to_hex(&oid));
|
||||
|
||||
|
|
|
@ -672,8 +672,10 @@ static int update_local_ref(struct ref *ref,
|
|||
return r;
|
||||
}
|
||||
|
||||
current = lookup_commit_reference_gently(&ref->old_oid, 1);
|
||||
updated = lookup_commit_reference_gently(&ref->new_oid, 1);
|
||||
current = lookup_commit_reference_gently(the_repository,
|
||||
&ref->old_oid, 1);
|
||||
updated = lookup_commit_reference_gently(the_repository,
|
||||
&ref->new_oid, 1);
|
||||
if (!current || !updated) {
|
||||
const char *msg;
|
||||
const char *what;
|
||||
|
@ -808,7 +810,8 @@ static int store_updated_refs(const char *raw_url, const char *remote_name,
|
|||
continue;
|
||||
}
|
||||
|
||||
commit = lookup_commit_reference_gently(&rm->old_oid,
|
||||
commit = lookup_commit_reference_gently(the_repository,
|
||||
&rm->old_oid,
|
||||
1);
|
||||
if (!commit)
|
||||
rm->fetch_head_status = FETCH_HEAD_NOT_FOR_MERGE;
|
||||
|
|
|
@ -11,6 +11,7 @@
|
|||
#include "branch.h"
|
||||
#include "fmt-merge-msg.h"
|
||||
#include "gpg-interface.h"
|
||||
#include "repository.h"
|
||||
|
||||
static const char * const fmt_merge_msg_usage[] = {
|
||||
N_("git fmt-merge-msg [-m <message>] [--log[=<n>] | --no-log] [--file <file>]"),
|
||||
|
@ -344,7 +345,9 @@ static void shortlog(const char *name,
|
|||
const struct object_id *oid = &origin_data->oid;
|
||||
int limit = opts->shortlog_len;
|
||||
|
||||
branch = deref_tag(parse_object(oid), oid_to_hex(oid), the_hash_algo->hexsz);
|
||||
branch = deref_tag(the_repository, parse_object(the_repository, oid),
|
||||
oid_to_hex(oid),
|
||||
the_hash_algo->hexsz);
|
||||
if (!branch || branch->type != OBJ_COMMIT)
|
||||
return;
|
||||
|
||||
|
@ -564,14 +567,14 @@ static void find_merge_parents(struct merge_parents *result,
|
|||
* "name" here and we do not want to contaminate its
|
||||
* util field yet.
|
||||
*/
|
||||
obj = parse_object(&oid);
|
||||
obj = parse_object(the_repository, &oid);
|
||||
parent = (struct commit *)peel_to_type(NULL, 0, obj, OBJ_COMMIT);
|
||||
if (!parent)
|
||||
continue;
|
||||
commit_list_insert(parent, &parents);
|
||||
add_merge_parent(result, &obj->oid, &parent->object.oid);
|
||||
}
|
||||
head_commit = lookup_commit(head);
|
||||
head_commit = lookup_commit(the_repository, head);
|
||||
if (head_commit)
|
||||
commit_list_insert(head_commit, &parents);
|
||||
reduce_heads_replace(&parents);
|
||||
|
|
|
@ -72,7 +72,7 @@ static const char *printable_type(struct object *obj)
|
|||
enum object_type type = oid_object_info(the_repository,
|
||||
&obj->oid, NULL);
|
||||
if (type > 0)
|
||||
object_as_type(obj, type, 0);
|
||||
object_as_type(the_repository, obj, type, 0);
|
||||
}
|
||||
|
||||
ret = type_name(obj->type);
|
||||
|
@ -394,7 +394,8 @@ static int fsck_obj_buffer(const struct object_id *oid, enum object_type type,
|
|||
* verify_packfile(), data_valid variable for details.
|
||||
*/
|
||||
struct object *obj;
|
||||
obj = parse_object_buffer(oid, type, size, buffer, eaten);
|
||||
obj = parse_object_buffer(the_repository, oid, type, size, buffer,
|
||||
eaten);
|
||||
if (!obj) {
|
||||
errors_found |= ERROR_OBJECT;
|
||||
return error("%s: object corrupt or missing", oid_to_hex(oid));
|
||||
|
@ -412,7 +413,7 @@ static void fsck_handle_reflog_oid(const char *refname, struct object_id *oid,
|
|||
struct object *obj;
|
||||
|
||||
if (!is_null_oid(oid)) {
|
||||
obj = lookup_object(oid->hash);
|
||||
obj = lookup_object(the_repository, oid->hash);
|
||||
if (obj && (obj->flags & HAS_OBJ)) {
|
||||
if (timestamp && name_objects)
|
||||
add_decoration(fsck_walk_options.object_names,
|
||||
|
@ -454,7 +455,7 @@ static int fsck_handle_ref(const char *refname, const struct object_id *oid,
|
|||
{
|
||||
struct object *obj;
|
||||
|
||||
obj = parse_object(oid);
|
||||
obj = parse_object(the_repository, oid);
|
||||
if (!obj) {
|
||||
if (is_promisor_object(oid)) {
|
||||
/*
|
||||
|
@ -527,7 +528,9 @@ static int fsck_loose(const struct object_id *oid, const char *path, void *data)
|
|||
if (!contents && type != OBJ_BLOB)
|
||||
BUG("read_loose_object streamed a non-blob");
|
||||
|
||||
obj = parse_object_buffer(oid, type, size, contents, &eaten);
|
||||
obj = parse_object_buffer(the_repository, oid, type, size,
|
||||
contents, &eaten);
|
||||
|
||||
if (!obj) {
|
||||
errors_found |= ERROR_OBJECT;
|
||||
error("%s: object could not be parsed: %s",
|
||||
|
@ -616,7 +619,7 @@ static int fsck_cache_tree(struct cache_tree *it)
|
|||
fprintf(stderr, "Checking cache tree\n");
|
||||
|
||||
if (0 <= it->entry_count) {
|
||||
struct object *obj = parse_object(&it->oid);
|
||||
struct object *obj = parse_object(the_repository, &it->oid);
|
||||
if (!obj) {
|
||||
error("%s: invalid sha1 pointer in cache-tree",
|
||||
oid_to_hex(&it->oid));
|
||||
|
@ -765,7 +768,8 @@ int cmd_fsck(int argc, const char **argv, const char *prefix)
|
|||
const char *arg = argv[i];
|
||||
struct object_id oid;
|
||||
if (!get_oid(arg, &oid)) {
|
||||
struct object *obj = lookup_object(oid.hash);
|
||||
struct object *obj = lookup_object(the_repository,
|
||||
oid.hash);
|
||||
|
||||
if (!obj || !(obj->flags & HAS_OBJ)) {
|
||||
if (is_promisor_object(&oid))
|
||||
|
@ -808,7 +812,8 @@ int cmd_fsck(int argc, const char **argv, const char *prefix)
|
|||
mode = active_cache[i]->ce_mode;
|
||||
if (S_ISGITLINK(mode))
|
||||
continue;
|
||||
blob = lookup_blob(&active_cache[i]->oid);
|
||||
blob = lookup_blob(the_repository,
|
||||
&active_cache[i]->oid);
|
||||
if (!blob)
|
||||
continue;
|
||||
obj = &blob->object;
|
||||
|
|
|
@ -647,7 +647,8 @@ static int grep_objects(struct grep_opt *opt, const struct pathspec *pathspec,
|
|||
|
||||
for (i = 0; i < nr; i++) {
|
||||
struct object *real_obj;
|
||||
real_obj = deref_tag(list->objects[i].item, NULL, 0);
|
||||
real_obj = deref_tag(the_repository, list->objects[i].item,
|
||||
NULL, 0);
|
||||
|
||||
/* load the gitmodules file for this rev */
|
||||
if (recurse_submodules) {
|
||||
|
|
|
@ -832,7 +832,7 @@ static void sha1_object(const void *data, struct object_entry *obj_entry,
|
|||
if (strict || do_fsck_object) {
|
||||
read_lock();
|
||||
if (type == OBJ_BLOB) {
|
||||
struct blob *blob = lookup_blob(oid);
|
||||
struct blob *blob = lookup_blob(the_repository, oid);
|
||||
if (blob)
|
||||
blob->object.flags |= FLAG_CHECKED;
|
||||
else
|
||||
|
@ -851,7 +851,8 @@ static void sha1_object(const void *data, struct object_entry *obj_entry,
|
|||
* we do not need to free the memory here, as the
|
||||
* buf is deleted by the caller.
|
||||
*/
|
||||
obj = parse_object_buffer(oid, type, size, buf,
|
||||
obj = parse_object_buffer(the_repository, oid, type,
|
||||
size, buf,
|
||||
&eaten);
|
||||
if (!obj)
|
||||
die(_("invalid %s"), type_name(type));
|
||||
|
|
|
@ -30,6 +30,7 @@
|
|||
#include "gpg-interface.h"
|
||||
#include "progress.h"
|
||||
#include "commit-slab.h"
|
||||
#include "repository.h"
|
||||
|
||||
#define MAIL_DEFAULT_WRAP 72
|
||||
|
||||
|
@ -619,7 +620,7 @@ int cmd_show(int argc, const char **argv, const char *prefix)
|
|||
rev.shown_one = 1;
|
||||
if (ret)
|
||||
break;
|
||||
o = parse_object(&t->tagged->oid);
|
||||
o = parse_object(the_repository, &t->tagged->oid);
|
||||
if (!o)
|
||||
ret = error(_("Could not read object %s"),
|
||||
oid_to_hex(&t->tagged->oid));
|
||||
|
@ -906,8 +907,8 @@ static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids)
|
|||
o2 = rev->pending.objects[1].item;
|
||||
flags1 = o1->flags;
|
||||
flags2 = o2->flags;
|
||||
c1 = lookup_commit_reference(&o1->oid);
|
||||
c2 = lookup_commit_reference(&o2->oid);
|
||||
c1 = lookup_commit_reference(the_repository, &o1->oid);
|
||||
c2 = lookup_commit_reference(the_repository, &o2->oid);
|
||||
|
||||
if ((flags1 & UNINTERESTING) == (flags2 & UNINTERESTING))
|
||||
die(_("Not a range."));
|
||||
|
@ -1864,7 +1865,8 @@ static int add_pending_commit(const char *arg, struct rev_info *revs, int flags)
|
|||
{
|
||||
struct object_id oid;
|
||||
if (get_oid(arg, &oid) == 0) {
|
||||
struct commit *commit = lookup_commit_reference(&oid);
|
||||
struct commit *commit = lookup_commit_reference(the_repository,
|
||||
&oid);
|
||||
if (commit) {
|
||||
commit->object.flags |= flags;
|
||||
add_pending_object(revs, &commit->object, arg);
|
||||
|
|
|
@ -6,6 +6,7 @@
|
|||
#include "diff.h"
|
||||
#include "revision.h"
|
||||
#include "parse-options.h"
|
||||
#include "repository.h"
|
||||
|
||||
static int show_merge_base(struct commit **rev, int rev_nr, int show_all)
|
||||
{
|
||||
|
@ -42,7 +43,7 @@ static struct commit *get_commit_reference(const char *arg)
|
|||
|
||||
if (get_oid(arg, &revkey))
|
||||
die("Not a valid object name %s", arg);
|
||||
r = lookup_commit_reference(&revkey);
|
||||
r = lookup_commit_reference(the_repository, &revkey);
|
||||
if (!r)
|
||||
die("Not a valid commit name %s", arg);
|
||||
|
||||
|
@ -123,7 +124,7 @@ static void add_one_commit(struct object_id *oid, struct rev_collect *revs)
|
|||
if (is_null_oid(oid))
|
||||
return;
|
||||
|
||||
commit = lookup_commit(oid);
|
||||
commit = lookup_commit(the_repository, oid);
|
||||
if (!commit ||
|
||||
(commit->object.flags & TMP_MARK) ||
|
||||
parse_commit(commit))
|
||||
|
@ -171,7 +172,7 @@ static int handle_fork_point(int argc, const char **argv)
|
|||
if (get_oid(commitname, &oid))
|
||||
die("Not a valid object name: '%s'", commitname);
|
||||
|
||||
derived = lookup_commit_reference(&oid);
|
||||
derived = lookup_commit_reference(the_repository, &oid);
|
||||
memset(&revs, 0, sizeof(revs));
|
||||
revs.initial = 1;
|
||||
for_each_reflog_ent(refname, collect_one_reflog_ent, &revs);
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#include "tree-walk.h"
|
||||
#include "xdiff-interface.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "blob.h"
|
||||
#include "exec-cmd.h"
|
||||
#include "merge-blobs.h"
|
||||
|
@ -170,7 +171,7 @@ static struct merge_list *create_entry(unsigned stage, unsigned mode, const stru
|
|||
res->stage = stage;
|
||||
res->path = path;
|
||||
res->mode = mode;
|
||||
res->blob = lookup_blob(oid);
|
||||
res->blob = lookup_blob(the_repository, oid);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
#include "builtin.h"
|
||||
#include "cache.h"
|
||||
#include "repository.h"
|
||||
#include "config.h"
|
||||
#include "commit.h"
|
||||
#include "tag.h"
|
||||
|
@ -203,7 +204,7 @@ static int tipcmp(const void *a_, const void *b_)
|
|||
|
||||
static int name_ref(const char *path, const struct object_id *oid, int flags, void *cb_data)
|
||||
{
|
||||
struct object *o = parse_object(oid);
|
||||
struct object *o = parse_object(the_repository, oid);
|
||||
struct name_ref_data *data = cb_data;
|
||||
int can_abbreviate_output = data->tags_only && data->name_only;
|
||||
int deref = 0;
|
||||
|
@ -261,7 +262,7 @@ static int name_ref(const char *path, const struct object_id *oid, int flags, vo
|
|||
struct tag *t = (struct tag *) o;
|
||||
if (!t->tagged)
|
||||
break; /* broken repository */
|
||||
o = parse_object(&t->tagged->oid);
|
||||
o = parse_object(the_repository, &t->tagged->oid);
|
||||
deref = 1;
|
||||
taggerdate = t->date;
|
||||
}
|
||||
|
@ -378,7 +379,8 @@ static void name_rev_line(char *p, struct name_ref_data *data)
|
|||
*(p+1) = 0;
|
||||
if (!get_oid(p - (GIT_SHA1_HEXSZ - 1), &oid)) {
|
||||
struct object *o =
|
||||
lookup_object(oid.hash);
|
||||
lookup_object(the_repository,
|
||||
oid.hash);
|
||||
if (o)
|
||||
name = get_rev_name(o, &buf);
|
||||
}
|
||||
|
@ -451,9 +453,10 @@ int cmd_name_rev(int argc, const char **argv, const char *prefix)
|
|||
}
|
||||
|
||||
commit = NULL;
|
||||
object = parse_object(&oid);
|
||||
object = parse_object(the_repository, &oid);
|
||||
if (object) {
|
||||
struct object *peeled = deref_tag(object, *argv, 0);
|
||||
struct object *peeled = deref_tag(the_repository,
|
||||
object, *argv, 0);
|
||||
if (peeled && peeled->type == OBJ_COMMIT)
|
||||
commit = (struct commit *)peeled;
|
||||
}
|
||||
|
|
|
@ -12,6 +12,7 @@
|
|||
#include "builtin.h"
|
||||
#include "notes.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "blob.h"
|
||||
#include "pretty.h"
|
||||
#include "refs.h"
|
||||
|
@ -711,7 +712,7 @@ static int merge_commit(struct notes_merge_options *o)
|
|||
|
||||
if (get_oid("NOTES_MERGE_PARTIAL", &oid))
|
||||
die(_("failed to read ref NOTES_MERGE_PARTIAL"));
|
||||
else if (!(partial = lookup_commit_reference(&oid)))
|
||||
else if (!(partial = lookup_commit_reference(the_repository, &oid)))
|
||||
die(_("could not find commit from NOTES_MERGE_PARTIAL."));
|
||||
else if (parse_commit(partial))
|
||||
die(_("could not parse commit from NOTES_MERGE_PARTIAL."));
|
||||
|
|
|
@ -2474,7 +2474,7 @@ static void add_tag_chain(const struct object_id *oid)
|
|||
if (packlist_find(&to_pack, oid->hash, NULL))
|
||||
return;
|
||||
|
||||
tag = lookup_tag(oid);
|
||||
tag = lookup_tag(the_repository, oid);
|
||||
while (1) {
|
||||
if (!tag || parse_tag(tag) || !tag->tagged)
|
||||
die("unable to pack objects reachable from tag %s",
|
||||
|
|
|
@ -40,7 +40,7 @@ static int prune_object(const struct object_id *oid, const char *fullpath,
|
|||
* Do we know about this object?
|
||||
* It must have been reachable
|
||||
*/
|
||||
if (lookup_object(oid->hash))
|
||||
if (lookup_object(the_repository, oid->hash))
|
||||
return 0;
|
||||
|
||||
if (lstat(fullpath, &st)) {
|
||||
|
|
|
@ -765,10 +765,13 @@ static int get_octopus_merge_base(struct object_id *merge_base,
|
|||
{
|
||||
struct commit_list *revs = NULL, *result;
|
||||
|
||||
commit_list_insert(lookup_commit_reference(curr_head), &revs);
|
||||
commit_list_insert(lookup_commit_reference(merge_head), &revs);
|
||||
commit_list_insert(lookup_commit_reference(the_repository, curr_head),
|
||||
&revs);
|
||||
commit_list_insert(lookup_commit_reference(the_repository, merge_head),
|
||||
&revs);
|
||||
if (!is_null_oid(fork_point))
|
||||
commit_list_insert(lookup_commit_reference(fork_point), &revs);
|
||||
commit_list_insert(lookup_commit_reference(the_repository, fork_point),
|
||||
&revs);
|
||||
|
||||
result = get_octopus_merge_bases(revs);
|
||||
free_commit_list(revs);
|
||||
|
@ -944,9 +947,11 @@ int cmd_pull(int argc, const char **argv, const char *prefix)
|
|||
struct commit_list *list = NULL;
|
||||
struct commit *merge_head, *head;
|
||||
|
||||
head = lookup_commit_reference(&orig_head);
|
||||
head = lookup_commit_reference(the_repository,
|
||||
&orig_head);
|
||||
commit_list_insert(head, &list);
|
||||
merge_head = lookup_commit_reference(&merge_heads.oid[0]);
|
||||
merge_head = lookup_commit_reference(the_repository,
|
||||
&merge_heads.oid[0]);
|
||||
if (is_descendant_of(merge_head, list)) {
|
||||
/* we can fast-forward this without invoking rebase */
|
||||
opt_ff = "--ff-only";
|
||||
|
|
|
@ -1095,8 +1095,8 @@ static const char *update(struct command *cmd, struct shallow_info *si)
|
|||
struct object *old_object, *new_object;
|
||||
struct commit *old_commit, *new_commit;
|
||||
|
||||
old_object = parse_object(old_oid);
|
||||
new_object = parse_object(new_oid);
|
||||
old_object = parse_object(the_repository, old_oid);
|
||||
new_object = parse_object(the_repository, new_oid);
|
||||
|
||||
if (!old_object || !new_object ||
|
||||
old_object->type != OBJ_COMMIT ||
|
||||
|
@ -1119,7 +1119,7 @@ static const char *update(struct command *cmd, struct shallow_info *si)
|
|||
|
||||
if (is_null_oid(new_oid)) {
|
||||
struct strbuf err = STRBUF_INIT;
|
||||
if (!parse_object(old_oid)) {
|
||||
if (!parse_object(the_repository, old_oid)) {
|
||||
old_oid = NULL;
|
||||
if (ref_exists(name)) {
|
||||
rp_warning("Allowing deletion of corrupt ref.");
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#include "config.h"
|
||||
#include "lockfile.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "commit.h"
|
||||
#include "refs.h"
|
||||
#include "dir.h"
|
||||
|
@ -65,7 +66,7 @@ static int tree_is_complete(const struct object_id *oid)
|
|||
int complete;
|
||||
struct tree *tree;
|
||||
|
||||
tree = lookup_tree(oid);
|
||||
tree = lookup_tree(the_repository, oid);
|
||||
if (!tree)
|
||||
return 0;
|
||||
if (tree->object.flags & SEEN)
|
||||
|
@ -129,7 +130,7 @@ static int commit_is_complete(struct commit *commit)
|
|||
struct commit_list *parent;
|
||||
|
||||
c = (struct commit *)object_array_pop(&study);
|
||||
if (!c->object.parsed && !parse_object(&c->object.oid))
|
||||
if (!c->object.parsed && !parse_object(the_repository, &c->object.oid))
|
||||
c->object.flags |= INCOMPLETE;
|
||||
|
||||
if (c->object.flags & INCOMPLETE) {
|
||||
|
@ -195,7 +196,7 @@ static int keep_entry(struct commit **it, struct object_id *oid)
|
|||
|
||||
if (is_null_oid(oid))
|
||||
return 1;
|
||||
commit = lookup_commit_reference_gently(oid, 1);
|
||||
commit = lookup_commit_reference_gently(the_repository, oid, 1);
|
||||
if (!commit)
|
||||
return 0;
|
||||
|
||||
|
@ -264,7 +265,8 @@ static int unreachable(struct expire_reflog_policy_cb *cb, struct commit *commit
|
|||
if (is_null_oid(oid))
|
||||
return 0;
|
||||
|
||||
commit = lookup_commit_reference_gently(oid, 1);
|
||||
commit = lookup_commit_reference_gently(the_repository, oid,
|
||||
1);
|
||||
|
||||
/* Not a commit -- keep it */
|
||||
if (!commit)
|
||||
|
@ -321,7 +323,7 @@ static int push_tip_to_list(const char *refname, const struct object_id *oid,
|
|||
struct commit *tip_commit;
|
||||
if (flags & REF_ISSYMREF)
|
||||
return 0;
|
||||
tip_commit = lookup_commit_reference_gently(oid, 1);
|
||||
tip_commit = lookup_commit_reference_gently(the_repository, oid, 1);
|
||||
if (!tip_commit)
|
||||
return 0;
|
||||
commit_list_insert(tip_commit, list);
|
||||
|
@ -338,7 +340,8 @@ static void reflog_expiry_prepare(const char *refname,
|
|||
cb->tip_commit = NULL;
|
||||
cb->unreachable_expire_kind = UE_HEAD;
|
||||
} else {
|
||||
cb->tip_commit = lookup_commit_reference_gently(oid, 1);
|
||||
cb->tip_commit = lookup_commit_reference_gently(the_repository,
|
||||
oid, 1);
|
||||
if (!cb->tip_commit)
|
||||
cb->unreachable_expire_kind = UE_ALWAYS;
|
||||
else
|
||||
|
|
|
@ -371,7 +371,7 @@ static int replace_parents(struct strbuf *buf, int argc, const char **argv)
|
|||
return error(_("Not a valid object name: '%s'"),
|
||||
argv[i]);
|
||||
}
|
||||
if (!lookup_commit_reference(&oid)) {
|
||||
if (!lookup_commit_reference(the_repository, &oid)) {
|
||||
strbuf_release(&new_parents);
|
||||
return error(_("could not parse %s"), argv[i]);
|
||||
}
|
||||
|
@ -402,10 +402,10 @@ static int check_one_mergetag(struct commit *commit,
|
|||
int i;
|
||||
|
||||
hash_object_file(extra->value, extra->len, type_name(OBJ_TAG), &tag_oid);
|
||||
tag = lookup_tag(&tag_oid);
|
||||
tag = lookup_tag(the_repository, &tag_oid);
|
||||
if (!tag)
|
||||
return error(_("bad mergetag in commit '%s'"), ref);
|
||||
if (parse_tag_buffer(tag, extra->value, extra->len))
|
||||
if (parse_tag_buffer(the_repository, tag, extra->value, extra->len))
|
||||
return error(_("malformed mergetag in commit '%s'"), ref);
|
||||
|
||||
/* iterate over new parents */
|
||||
|
@ -443,7 +443,7 @@ static int create_graft(int argc, const char **argv, int force, int gentle)
|
|||
|
||||
if (get_oid(old_ref, &old_oid) < 0)
|
||||
return error(_("Not a valid object name: '%s'"), old_ref);
|
||||
commit = lookup_commit_reference(&old_oid);
|
||||
commit = lookup_commit_reference(the_repository, &old_oid);
|
||||
if (!commit)
|
||||
return error(_("could not parse %s"), old_ref);
|
||||
|
||||
|
|
|
@ -319,7 +319,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
|
|||
struct commit *commit;
|
||||
if (get_oid_committish(rev, &oid))
|
||||
die(_("Failed to resolve '%s' as a valid revision."), rev);
|
||||
commit = lookup_commit_reference(&oid);
|
||||
commit = lookup_commit_reference(the_repository, &oid);
|
||||
if (!commit)
|
||||
die(_("Could not parse object '%s'."), rev);
|
||||
oidcpy(&oid, &commit->object.oid);
|
||||
|
@ -396,7 +396,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
|
|||
update_ref_status = reset_refs(rev, &oid);
|
||||
|
||||
if (reset_type == HARD && !update_ref_status && !quiet)
|
||||
print_new_head_line(lookup_commit_reference(&oid));
|
||||
print_new_head_line(lookup_commit_reference(the_repository, &oid));
|
||||
}
|
||||
if (!pathspec.nr)
|
||||
remove_branch_state();
|
||||
|
|
|
@ -240,7 +240,7 @@ static int finish_object(struct object *obj, const char *name, void *cb_data)
|
|||
return 1;
|
||||
}
|
||||
if (info->revs->verify_objects && !obj->parsed && obj->type != OBJ_COMMIT)
|
||||
parse_object(&obj->oid);
|
||||
parse_object(the_repository, &obj->oid);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -280,8 +280,8 @@ static int try_difference(const char *arg)
|
|||
if (symmetric) {
|
||||
struct commit_list *exclude;
|
||||
struct commit *a, *b;
|
||||
a = lookup_commit_reference(&start_oid);
|
||||
b = lookup_commit_reference(&end_oid);
|
||||
a = lookup_commit_reference(the_repository, &start_oid);
|
||||
b = lookup_commit_reference(the_repository, &end_oid);
|
||||
if (!a || !b) {
|
||||
*dotdot = '.';
|
||||
return 0;
|
||||
|
@ -333,7 +333,7 @@ static int try_parent_shorthands(const char *arg)
|
|||
|
||||
*dotdot = 0;
|
||||
if (get_oid_committish(arg, &oid) ||
|
||||
!(commit = lookup_commit_reference(&oid))) {
|
||||
!(commit = lookup_commit_reference(the_repository, &oid))) {
|
||||
*dotdot = '^';
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -378,7 +378,8 @@ static void sort_ref_range(int bottom, int top)
|
|||
static int append_ref(const char *refname, const struct object_id *oid,
|
||||
int allow_dups)
|
||||
{
|
||||
struct commit *commit = lookup_commit_reference_gently(oid, 1);
|
||||
struct commit *commit = lookup_commit_reference_gently(the_repository,
|
||||
oid, 1);
|
||||
int i;
|
||||
|
||||
if (!commit)
|
||||
|
@ -830,7 +831,7 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
MAX_REVS), MAX_REVS);
|
||||
if (get_oid(ref_name[num_rev], &revkey))
|
||||
die(_("'%s' is not a valid ref."), ref_name[num_rev]);
|
||||
commit = lookup_commit_reference(&revkey);
|
||||
commit = lookup_commit_reference(the_repository, &revkey);
|
||||
if (!commit)
|
||||
die(_("cannot find commit %s (%s)"),
|
||||
ref_name[num_rev], oid_to_hex(&revkey));
|
||||
|
|
|
@ -313,7 +313,7 @@ static void create_reflog_msg(const struct object_id *oid, struct strbuf *sb)
|
|||
}
|
||||
free(buf);
|
||||
|
||||
if ((c = lookup_commit_reference(oid)) != NULL)
|
||||
if ((c = lookup_commit_reference(the_repository, oid)) != NULL)
|
||||
strbuf_addf(sb, ", %s", show_date(c->date, 0, DATE_MODE(SHORT)));
|
||||
break;
|
||||
case OBJ_TREE:
|
||||
|
|
|
@ -254,7 +254,7 @@ static void write_object(unsigned nr, enum object_type type,
|
|||
added_object(nr, type, buf, size);
|
||||
free(buf);
|
||||
|
||||
blob = lookup_blob(&obj_list[nr].oid);
|
||||
blob = lookup_blob(the_repository, &obj_list[nr].oid);
|
||||
if (blob)
|
||||
blob->object.flags |= FLAG_WRITTEN;
|
||||
else
|
||||
|
@ -265,7 +265,8 @@ static void write_object(unsigned nr, enum object_type type,
|
|||
int eaten;
|
||||
hash_object_file(buf, size, type_name(type), &obj_list[nr].oid);
|
||||
added_object(nr, type, buf, size);
|
||||
obj = parse_object_buffer(&obj_list[nr].oid, type, size, buf,
|
||||
obj = parse_object_buffer(the_repository, &obj_list[nr].oid,
|
||||
type, size, buf,
|
||||
&eaten);
|
||||
if (!obj)
|
||||
die("invalid %s", type_name(type));
|
||||
|
@ -331,7 +332,7 @@ static int resolve_against_held(unsigned nr, const struct object_id *base,
|
|||
{
|
||||
struct object *obj;
|
||||
struct obj_buffer *obj_buffer;
|
||||
obj = lookup_object(base->hash);
|
||||
obj = lookup_object(the_repository, base->hash);
|
||||
if (!obj)
|
||||
return 0;
|
||||
obj_buffer = lookup_object_buffer(obj);
|
||||
|
|
|
@ -9,6 +9,7 @@
|
|||
#include "config.h"
|
||||
#include "builtin.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "commit.h"
|
||||
#include "run-command.h"
|
||||
#include <signal.h>
|
||||
|
@ -27,7 +28,8 @@ static int run_gpg_verify(const struct object_id *oid, const char *buf, unsigned
|
|||
|
||||
memset(&signature_check, 0, sizeof(signature_check));
|
||||
|
||||
ret = check_commit_signature(lookup_commit(oid), &signature_check);
|
||||
ret = check_commit_signature(lookup_commit(the_repository, oid),
|
||||
&signature_check);
|
||||
print_signature_buffer(&signature_check, flags);
|
||||
|
||||
signature_check_clear(&signature_check);
|
||||
|
|
10
bundle.c
10
bundle.c
|
@ -2,6 +2,7 @@
|
|||
#include "lockfile.h"
|
||||
#include "bundle.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "object.h"
|
||||
#include "commit.h"
|
||||
#include "diff.h"
|
||||
|
@ -142,7 +143,7 @@ int verify_bundle(struct bundle_header *header, int verbose)
|
|||
init_revisions(&revs, NULL);
|
||||
for (i = 0; i < p->nr; i++) {
|
||||
struct ref_list_entry *e = p->list + i;
|
||||
struct object *o = parse_object(&e->oid);
|
||||
struct object *o = parse_object(the_repository, &e->oid);
|
||||
if (o) {
|
||||
o->flags |= PREREQ_MARK;
|
||||
add_pending_object(&revs, o, e->name);
|
||||
|
@ -167,7 +168,7 @@ int verify_bundle(struct bundle_header *header, int verbose)
|
|||
|
||||
for (i = 0; i < p->nr; i++) {
|
||||
struct ref_list_entry *e = p->list + i;
|
||||
struct object *o = parse_object(&e->oid);
|
||||
struct object *o = parse_object(the_repository, &e->oid);
|
||||
assert(o); /* otherwise we'd have returned early */
|
||||
if (o->flags & SHOWN)
|
||||
continue;
|
||||
|
@ -179,7 +180,7 @@ int verify_bundle(struct bundle_header *header, int verbose)
|
|||
/* Clean up objects used, as they will be reused. */
|
||||
for (i = 0; i < p->nr; i++) {
|
||||
struct ref_list_entry *e = p->list + i;
|
||||
commit = lookup_commit_reference_gently(&e->oid, 1);
|
||||
commit = lookup_commit_reference_gently(the_repository, &e->oid, 1);
|
||||
if (commit)
|
||||
clear_commit_marks(commit, ALL_REV_FLAGS);
|
||||
}
|
||||
|
@ -374,7 +375,8 @@ static int write_bundle_refs(int bundle_fd, struct rev_info *revs)
|
|||
* in terms of a tag (e.g. v2.0 from the range
|
||||
* "v1.0..v2.0")?
|
||||
*/
|
||||
struct commit *one = lookup_commit_reference(&oid);
|
||||
struct commit *one = lookup_commit_reference(the_repository,
|
||||
&oid);
|
||||
struct object *obj;
|
||||
|
||||
if (e->item == &(one->object)) {
|
||||
|
|
|
@ -671,7 +671,8 @@ static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
|
|||
cnt++;
|
||||
else {
|
||||
struct cache_tree_sub *sub;
|
||||
struct tree *subtree = lookup_tree(entry.oid);
|
||||
struct tree *subtree = lookup_tree(the_repository,
|
||||
entry.oid);
|
||||
if (!subtree->object.parsed)
|
||||
parse_tree(subtree);
|
||||
sub = cache_tree_sub(it, entry.path);
|
||||
|
|
|
@ -249,7 +249,7 @@ static struct commit_list **insert_parent_or_die(struct commit_graph *g,
|
|||
die("invalid parent position %"PRIu64, pos);
|
||||
|
||||
hashcpy(oid.hash, g->chunk_oid_lookup + g->hash_len * pos);
|
||||
c = lookup_commit(&oid);
|
||||
c = lookup_commit(the_repository, &oid);
|
||||
if (!c)
|
||||
die("could not find commit %s", oid_to_hex(&oid));
|
||||
c->graph_pos = pos;
|
||||
|
@ -363,7 +363,7 @@ static struct tree *load_tree_for_commit(struct commit_graph *g, struct commit *
|
|||
GRAPH_DATA_WIDTH * (c->graph_pos);
|
||||
|
||||
hashcpy(oid.hash, commit_data);
|
||||
c->maybe_tree = lookup_tree(&oid);
|
||||
c->maybe_tree = lookup_tree(the_repository, &oid);
|
||||
|
||||
return c->maybe_tree;
|
||||
}
|
||||
|
@ -593,7 +593,7 @@ static void close_reachable(struct packed_oid_list *oids)
|
|||
struct commit *commit;
|
||||
|
||||
for (i = 0; i < oids->nr; i++) {
|
||||
commit = lookup_commit(&oids->list[i]);
|
||||
commit = lookup_commit(the_repository, &oids->list[i]);
|
||||
if (commit)
|
||||
commit->object.flags |= UNINTERESTING;
|
||||
}
|
||||
|
@ -604,14 +604,14 @@ static void close_reachable(struct packed_oid_list *oids)
|
|||
* closure.
|
||||
*/
|
||||
for (i = 0; i < oids->nr; i++) {
|
||||
commit = lookup_commit(&oids->list[i]);
|
||||
commit = lookup_commit(the_repository, &oids->list[i]);
|
||||
|
||||
if (commit && !parse_commit(commit))
|
||||
add_missing_parents(oids, commit);
|
||||
}
|
||||
|
||||
for (i = 0; i < oids->nr; i++) {
|
||||
commit = lookup_commit(&oids->list[i]);
|
||||
commit = lookup_commit(the_repository, &oids->list[i]);
|
||||
|
||||
if (commit)
|
||||
commit->object.flags &= ~UNINTERESTING;
|
||||
|
@ -744,7 +744,7 @@ void write_commit_graph(const char *obj_dir,
|
|||
parse_oid_hex(commit_hex->items[i].string, &oid, &end))
|
||||
continue;
|
||||
|
||||
result = lookup_commit_reference_gently(&oid, 1);
|
||||
result = lookup_commit_reference_gently(the_repository, &oid, 1);
|
||||
|
||||
if (result) {
|
||||
ALLOC_GROW(oids.list, oids.nr + 1, oids.alloc);
|
||||
|
@ -780,7 +780,7 @@ void write_commit_graph(const char *obj_dir,
|
|||
if (i > 0 && !oidcmp(&oids.list[i-1], &oids.list[i]))
|
||||
continue;
|
||||
|
||||
commits.list[commits.nr] = lookup_commit(&oids.list[i]);
|
||||
commits.list[commits.nr] = lookup_commit(the_repository, &oids.list[i]);
|
||||
parse_commit(commits.list[commits.nr]);
|
||||
|
||||
for (parent = commits.list[commits.nr]->parents;
|
||||
|
@ -924,7 +924,7 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g)
|
|||
cur_fanout_pos++;
|
||||
}
|
||||
|
||||
graph_commit = lookup_commit(&cur_oid);
|
||||
graph_commit = lookup_commit(r, &cur_oid);
|
||||
if (!parse_commit_in_graph_one(g, graph_commit))
|
||||
graph_report("failed to parse %s from commit-graph",
|
||||
oid_to_hex(&cur_oid));
|
||||
|
@ -950,7 +950,7 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g)
|
|||
|
||||
hashcpy(cur_oid.hash, g->chunk_oid_lookup + g->hash_len * i);
|
||||
|
||||
graph_commit = lookup_commit(&cur_oid);
|
||||
graph_commit = lookup_commit(r, &cur_oid);
|
||||
odb_commit = (struct commit *)create_object(r, cur_oid.hash, alloc_commit_node(r));
|
||||
if (parse_commit_internal(odb_commit, 0, 0)) {
|
||||
graph_report("failed to parse %s from object database",
|
||||
|
|
|
@ -11,8 +11,6 @@
|
|||
|
||||
#define implement_commit_slab(slabname, elemtype, scope) \
|
||||
\
|
||||
static int stat_ ##slabname## realloc; \
|
||||
\
|
||||
scope void init_ ##slabname## _with_stride(struct slabname *s, \
|
||||
unsigned stride) \
|
||||
{ \
|
||||
|
@ -54,7 +52,6 @@ scope elemtype *slabname## _at_peek(struct slabname *s, \
|
|||
if (!add_if_missing) \
|
||||
return NULL; \
|
||||
REALLOC_ARRAY(s->slab, nth_slab + 1); \
|
||||
stat_ ##slabname## realloc++; \
|
||||
for (i = s->slab_count; i <= nth_slab; i++) \
|
||||
s->slab[i] = NULL; \
|
||||
s->slab_count = nth_slab + 1; \
|
||||
|
|
80
commit.c
80
commit.c
|
@ -24,24 +24,26 @@ int save_commit_buffer = 1;
|
|||
|
||||
const char *commit_type = "commit";
|
||||
|
||||
struct commit *lookup_commit_reference_gently(const struct object_id *oid,
|
||||
int quiet)
|
||||
struct commit *lookup_commit_reference_gently(struct repository *r,
|
||||
const struct object_id *oid, int quiet)
|
||||
{
|
||||
struct object *obj = deref_tag(parse_object(oid), NULL, 0);
|
||||
struct object *obj = deref_tag(r,
|
||||
parse_object(r, oid),
|
||||
NULL, 0);
|
||||
|
||||
if (!obj)
|
||||
return NULL;
|
||||
return object_as_type(obj, OBJ_COMMIT, quiet);
|
||||
return object_as_type(r, obj, OBJ_COMMIT, quiet);
|
||||
}
|
||||
|
||||
struct commit *lookup_commit_reference(const struct object_id *oid)
|
||||
struct commit *lookup_commit_reference(struct repository *r, const struct object_id *oid)
|
||||
{
|
||||
return lookup_commit_reference_gently(oid, 0);
|
||||
return lookup_commit_reference_gently(r, oid, 0);
|
||||
}
|
||||
|
||||
struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name)
|
||||
{
|
||||
struct commit *c = lookup_commit_reference(oid);
|
||||
struct commit *c = lookup_commit_reference(the_repository, oid);
|
||||
if (!c)
|
||||
die(_("could not parse %s"), ref_name);
|
||||
if (oidcmp(oid, &c->object.oid)) {
|
||||
|
@ -51,13 +53,13 @@ struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref
|
|||
return c;
|
||||
}
|
||||
|
||||
struct commit *lookup_commit(const struct object_id *oid)
|
||||
struct commit *lookup_commit(struct repository *r, const struct object_id *oid)
|
||||
{
|
||||
struct object *obj = lookup_object(oid->hash);
|
||||
struct object *obj = lookup_object(r, oid->hash);
|
||||
if (!obj)
|
||||
return create_object(the_repository, oid->hash,
|
||||
alloc_commit_node(the_repository));
|
||||
return object_as_type(obj, OBJ_COMMIT, 0);
|
||||
return create_object(r, oid->hash,
|
||||
alloc_commit_node(r));
|
||||
return object_as_type(r, obj, OBJ_COMMIT, 0);
|
||||
}
|
||||
|
||||
struct commit *lookup_commit_reference_by_name(const char *name)
|
||||
|
@ -67,7 +69,7 @@ struct commit *lookup_commit_reference_by_name(const char *name)
|
|||
|
||||
if (get_oid_committish(name, &oid))
|
||||
return NULL;
|
||||
commit = lookup_commit_reference(&oid);
|
||||
commit = lookup_commit_reference(the_repository, &oid);
|
||||
if (parse_commit(commit))
|
||||
return NULL;
|
||||
return commit;
|
||||
|
@ -259,18 +261,32 @@ struct commit_buffer {
|
|||
unsigned long size;
|
||||
};
|
||||
define_commit_slab(buffer_slab, struct commit_buffer);
|
||||
static struct buffer_slab buffer_slab = COMMIT_SLAB_INIT(1, buffer_slab);
|
||||
|
||||
void set_commit_buffer(struct commit *commit, void *buffer, unsigned long size)
|
||||
struct buffer_slab *allocate_commit_buffer_slab(void)
|
||||
{
|
||||
struct commit_buffer *v = buffer_slab_at(&buffer_slab, commit);
|
||||
struct buffer_slab *bs = xmalloc(sizeof(*bs));
|
||||
init_buffer_slab(bs);
|
||||
return bs;
|
||||
}
|
||||
|
||||
void free_commit_buffer_slab(struct buffer_slab *bs)
|
||||
{
|
||||
clear_buffer_slab(bs);
|
||||
free(bs);
|
||||
}
|
||||
|
||||
void set_commit_buffer(struct repository *r, struct commit *commit, void *buffer, unsigned long size)
|
||||
{
|
||||
struct commit_buffer *v = buffer_slab_at(
|
||||
r->parsed_objects->buffer_slab, commit);
|
||||
v->buffer = buffer;
|
||||
v->size = size;
|
||||
}
|
||||
|
||||
const void *get_cached_commit_buffer(const struct commit *commit, unsigned long *sizep)
|
||||
const void *get_cached_commit_buffer(struct repository *r, const struct commit *commit, unsigned long *sizep)
|
||||
{
|
||||
struct commit_buffer *v = buffer_slab_peek(&buffer_slab, commit);
|
||||
struct commit_buffer *v = buffer_slab_peek(
|
||||
r->parsed_objects->buffer_slab, commit);
|
||||
if (!v) {
|
||||
if (sizep)
|
||||
*sizep = 0;
|
||||
|
@ -283,7 +299,7 @@ const void *get_cached_commit_buffer(const struct commit *commit, unsigned long
|
|||
|
||||
const void *get_commit_buffer(const struct commit *commit, unsigned long *sizep)
|
||||
{
|
||||
const void *ret = get_cached_commit_buffer(commit, sizep);
|
||||
const void *ret = get_cached_commit_buffer(the_repository, commit, sizep);
|
||||
if (!ret) {
|
||||
enum object_type type;
|
||||
unsigned long size;
|
||||
|
@ -302,14 +318,16 @@ const void *get_commit_buffer(const struct commit *commit, unsigned long *sizep)
|
|||
|
||||
void unuse_commit_buffer(const struct commit *commit, const void *buffer)
|
||||
{
|
||||
struct commit_buffer *v = buffer_slab_peek(&buffer_slab, commit);
|
||||
struct commit_buffer *v = buffer_slab_peek(
|
||||
the_repository->parsed_objects->buffer_slab, commit);
|
||||
if (!(v && v->buffer == buffer))
|
||||
free((void *)buffer);
|
||||
}
|
||||
|
||||
void free_commit_buffer(struct commit *commit)
|
||||
{
|
||||
struct commit_buffer *v = buffer_slab_peek(&buffer_slab, commit);
|
||||
struct commit_buffer *v = buffer_slab_peek(
|
||||
the_repository->parsed_objects->buffer_slab, commit);
|
||||
if (v) {
|
||||
FREE_AND_NULL(v->buffer);
|
||||
v->size = 0;
|
||||
|
@ -345,7 +363,8 @@ void release_commit_memory(struct commit *c)
|
|||
|
||||
const void *detach_commit_buffer(struct commit *commit, unsigned long *sizep)
|
||||
{
|
||||
struct commit_buffer *v = buffer_slab_peek(&buffer_slab, commit);
|
||||
struct commit_buffer *v = buffer_slab_peek(
|
||||
the_repository->parsed_objects->buffer_slab, commit);
|
||||
void *ret;
|
||||
|
||||
if (!v) {
|
||||
|
@ -362,7 +381,7 @@ const void *detach_commit_buffer(struct commit *commit, unsigned long *sizep)
|
|||
return ret;
|
||||
}
|
||||
|
||||
int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long size, int check_graph)
|
||||
int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph)
|
||||
{
|
||||
const char *tail = buffer;
|
||||
const char *bufptr = buffer;
|
||||
|
@ -382,11 +401,11 @@ int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long s
|
|||
if (get_oid_hex(bufptr + 5, &parent) < 0)
|
||||
return error("bad tree pointer in commit %s",
|
||||
oid_to_hex(&item->object.oid));
|
||||
item->maybe_tree = lookup_tree(&parent);
|
||||
item->maybe_tree = lookup_tree(r, &parent);
|
||||
bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
|
||||
pptr = &item->parents;
|
||||
|
||||
graft = lookup_commit_graft(the_repository, &item->object.oid);
|
||||
graft = lookup_commit_graft(r, &item->object.oid);
|
||||
while (bufptr + parent_entry_len < tail && !memcmp(bufptr, "parent ", 7)) {
|
||||
struct commit *new_parent;
|
||||
|
||||
|
@ -401,7 +420,7 @@ int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long s
|
|||
*/
|
||||
if (graft && (graft->nr_parent < 0 || grafts_replace_parents))
|
||||
continue;
|
||||
new_parent = lookup_commit(&parent);
|
||||
new_parent = lookup_commit(r, &parent);
|
||||
if (new_parent)
|
||||
pptr = &commit_list_insert(new_parent, pptr)->next;
|
||||
}
|
||||
|
@ -409,7 +428,8 @@ int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long s
|
|||
int i;
|
||||
struct commit *new_parent;
|
||||
for (i = 0; i < graft->nr_parent; i++) {
|
||||
new_parent = lookup_commit(&graft->parent[i]);
|
||||
new_parent = lookup_commit(r,
|
||||
&graft->parent[i]);
|
||||
if (!new_parent)
|
||||
continue;
|
||||
pptr = &commit_list_insert(new_parent, pptr)->next;
|
||||
|
@ -447,9 +467,9 @@ int parse_commit_internal(struct commit *item, int quiet_on_missing, int use_com
|
|||
oid_to_hex(&item->object.oid));
|
||||
}
|
||||
|
||||
ret = parse_commit_buffer(item, buffer, size, 0);
|
||||
ret = parse_commit_buffer(the_repository, item, buffer, size, 0);
|
||||
if (save_commit_buffer && !ret) {
|
||||
set_commit_buffer(item, buffer, size);
|
||||
set_commit_buffer(the_repository, item, buffer, size);
|
||||
return 0;
|
||||
}
|
||||
free(buffer);
|
||||
|
@ -1698,7 +1718,7 @@ struct commit *get_merge_parent(const char *name)
|
|||
struct object_id oid;
|
||||
if (get_oid(name, &oid))
|
||||
return NULL;
|
||||
obj = parse_object(&oid);
|
||||
obj = parse_object(the_repository, &oid);
|
||||
commit = (struct commit *)peel_to_type(name, 0, obj, OBJ_COMMIT);
|
||||
if (commit && !merge_remote_util(commit))
|
||||
set_merge_remote_desc(commit, name, obj);
|
||||
|
|
18
commit.h
18
commit.h
|
@ -63,9 +63,11 @@ enum decoration_type {
|
|||
void add_name_decoration(enum decoration_type type, const char *name, struct object *obj);
|
||||
const struct name_decoration *get_name_decoration(const struct object *obj);
|
||||
|
||||
struct commit *lookup_commit(const struct object_id *oid);
|
||||
struct commit *lookup_commit_reference(const struct object_id *oid);
|
||||
struct commit *lookup_commit_reference_gently(const struct object_id *oid,
|
||||
struct commit *lookup_commit(struct repository *r, const struct object_id *oid);
|
||||
struct commit *lookup_commit_reference(struct repository *r,
|
||||
const struct object_id *oid);
|
||||
struct commit *lookup_commit_reference_gently(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
int quiet);
|
||||
struct commit *lookup_commit_reference_by_name(const char *name);
|
||||
|
||||
|
@ -76,7 +78,7 @@ struct commit *lookup_commit_reference_by_name(const char *name);
|
|||
*/
|
||||
struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name);
|
||||
|
||||
int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long size, int check_graph);
|
||||
int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph);
|
||||
int parse_commit_internal(struct commit *item, int quiet_on_missing, int use_commit_graph);
|
||||
int parse_commit_gently(struct commit *item, int quiet_on_missing);
|
||||
static inline int parse_commit(struct commit *item)
|
||||
|
@ -85,17 +87,21 @@ static inline int parse_commit(struct commit *item)
|
|||
}
|
||||
void parse_commit_or_die(struct commit *item);
|
||||
|
||||
struct buffer_slab;
|
||||
struct buffer_slab *allocate_commit_buffer_slab(void);
|
||||
void free_commit_buffer_slab(struct buffer_slab *bs);
|
||||
|
||||
/*
|
||||
* Associate an object buffer with the commit. The ownership of the
|
||||
* memory is handed over to the commit, and must be free()-able.
|
||||
*/
|
||||
void set_commit_buffer(struct commit *, void *buffer, unsigned long size);
|
||||
void set_commit_buffer(struct repository *r, struct commit *, void *buffer, unsigned long size);
|
||||
|
||||
/*
|
||||
* Get any cached object buffer associated with the commit. Returns NULL
|
||||
* if none. The resulting memory should not be freed.
|
||||
*/
|
||||
const void *get_cached_commit_buffer(const struct commit *, unsigned long *size);
|
||||
const void *get_cached_commit_buffer(struct repository *, const struct commit *, unsigned long *size);
|
||||
|
||||
/*
|
||||
* Get the commit's object contents, either from cache or by reading the object
|
||||
|
|
|
@ -1724,8 +1724,10 @@ static int update_branch(struct branch *b)
|
|||
if (!force_update && !is_null_oid(&old_oid)) {
|
||||
struct commit *old_cmit, *new_cmit;
|
||||
|
||||
old_cmit = lookup_commit_reference_gently(&old_oid, 0);
|
||||
new_cmit = lookup_commit_reference_gently(&b->oid, 0);
|
||||
old_cmit = lookup_commit_reference_gently(the_repository,
|
||||
&old_oid, 0);
|
||||
new_cmit = lookup_commit_reference_gently(the_repository,
|
||||
&b->oid, 0);
|
||||
if (!old_cmit || !new_cmit)
|
||||
return error("Branch %s is missing commits.", b->name);
|
||||
|
||||
|
|
36
fetch-pack.c
36
fetch-pack.c
|
@ -78,7 +78,7 @@ static void cache_one_alternate(const char *refname,
|
|||
void *vcache)
|
||||
{
|
||||
struct alternate_object_cache *cache = vcache;
|
||||
struct object *obj = parse_object(oid);
|
||||
struct object *obj = parse_object(the_repository, oid);
|
||||
|
||||
if (!obj || (obj->flags & ALTERNATE))
|
||||
return;
|
||||
|
@ -109,7 +109,9 @@ static int rev_list_insert_ref(struct fetch_negotiator *negotiator,
|
|||
const char *refname,
|
||||
const struct object_id *oid)
|
||||
{
|
||||
struct object *o = deref_tag(parse_object(oid), refname, 0);
|
||||
struct object *o = deref_tag(the_repository,
|
||||
parse_object(the_repository, oid),
|
||||
refname, 0);
|
||||
|
||||
if (o && o->type == OBJ_COMMIT)
|
||||
negotiator->add_tip(negotiator, (struct commit *)o);
|
||||
|
@ -251,7 +253,7 @@ static int find_common(struct fetch_negotiator *negotiator,
|
|||
* interested in the case we *know* the object is
|
||||
* reachable and we have already scanned it.
|
||||
*/
|
||||
if (((o = lookup_object(remote->hash)) != NULL) &&
|
||||
if (((o = lookup_object(the_repository, remote->hash)) != NULL) &&
|
||||
(o->flags & COMPLETE)) {
|
||||
continue;
|
||||
}
|
||||
|
@ -325,10 +327,10 @@ static int find_common(struct fetch_negotiator *negotiator,
|
|||
if (skip_prefix(line, "unshallow ", &arg)) {
|
||||
if (get_oid_hex(arg, &oid))
|
||||
die(_("invalid unshallow line: %s"), line);
|
||||
if (!lookup_object(oid.hash))
|
||||
if (!lookup_object(the_repository, oid.hash))
|
||||
die(_("object not found: %s"), line);
|
||||
/* make sure that it is parsed as shallow */
|
||||
if (!parse_object(&oid))
|
||||
if (!parse_object(the_repository, &oid))
|
||||
die(_("error in object: %s"), line);
|
||||
if (unregister_shallow(&oid))
|
||||
die(_("no shallow found: %s"), line);
|
||||
|
@ -387,8 +389,10 @@ static int find_common(struct fetch_negotiator *negotiator,
|
|||
case ACK_ready:
|
||||
case ACK_continue: {
|
||||
struct commit *commit =
|
||||
lookup_commit(result_oid);
|
||||
lookup_commit(the_repository,
|
||||
result_oid);
|
||||
int was_common;
|
||||
|
||||
if (!commit)
|
||||
die(_("invalid commit %s"), oid_to_hex(result_oid));
|
||||
was_common = negotiator->ack(negotiator, commit);
|
||||
|
@ -462,14 +466,14 @@ static struct commit_list *complete;
|
|||
|
||||
static int mark_complete(const struct object_id *oid)
|
||||
{
|
||||
struct object *o = parse_object(oid);
|
||||
struct object *o = parse_object(the_repository, oid);
|
||||
|
||||
while (o && o->type == OBJ_TAG) {
|
||||
struct tag *t = (struct tag *) o;
|
||||
if (!t->tagged)
|
||||
break; /* broken repository */
|
||||
o->flags |= COMPLETE;
|
||||
o = parse_object(&t->tagged->oid);
|
||||
o = parse_object(the_repository, &t->tagged->oid);
|
||||
}
|
||||
if (o && o->type == OBJ_COMMIT) {
|
||||
struct commit *commit = (struct commit *)o;
|
||||
|
@ -670,7 +674,7 @@ static void mark_complete_and_common_ref(struct fetch_negotiator *negotiator,
|
|||
|
||||
if (!has_object_file_with_flags(&ref->old_oid, flags))
|
||||
continue;
|
||||
o = parse_object(&ref->old_oid);
|
||||
o = parse_object(the_repository, &ref->old_oid);
|
||||
if (!o)
|
||||
continue;
|
||||
|
||||
|
@ -701,7 +705,9 @@ static void mark_complete_and_common_ref(struct fetch_negotiator *negotiator,
|
|||
* Don't mark them common yet; the server has to be told so first.
|
||||
*/
|
||||
for (ref = *refs; ref; ref = ref->next) {
|
||||
struct object *o = deref_tag(lookup_object(ref->old_oid.hash),
|
||||
struct object *o = deref_tag(the_repository,
|
||||
lookup_object(the_repository,
|
||||
ref->old_oid.hash),
|
||||
NULL, 0);
|
||||
|
||||
if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
|
||||
|
@ -729,7 +735,7 @@ static int everything_local(struct fetch_pack_args *args,
|
|||
const struct object_id *remote = &ref->old_oid;
|
||||
struct object *o;
|
||||
|
||||
o = lookup_object(remote->hash);
|
||||
o = lookup_object(the_repository, remote->hash);
|
||||
if (!o || !(o->flags & COMPLETE)) {
|
||||
retval = 0;
|
||||
print_verbose(args, "want %s (%s)", oid_to_hex(remote),
|
||||
|
@ -1032,7 +1038,7 @@ static void add_wants(const struct ref *wants, struct strbuf *req_buf)
|
|||
* interested in the case we *know* the object is
|
||||
* reachable and we have already scanned it.
|
||||
*/
|
||||
if (((o = lookup_object(remote->hash)) != NULL) &&
|
||||
if (((o = lookup_object(the_repository, remote->hash)) != NULL) &&
|
||||
(o->flags & COMPLETE)) {
|
||||
continue;
|
||||
}
|
||||
|
@ -1196,7 +1202,7 @@ static int process_acks(struct fetch_negotiator *negotiator,
|
|||
if (!get_oid_hex(arg, &oid)) {
|
||||
struct commit *commit;
|
||||
oidset_insert(common, &oid);
|
||||
commit = lookup_commit(&oid);
|
||||
commit = lookup_commit(the_repository, &oid);
|
||||
negotiator->ack(negotiator, commit);
|
||||
}
|
||||
continue;
|
||||
|
@ -1235,10 +1241,10 @@ static void receive_shallow_info(struct fetch_pack_args *args,
|
|||
if (skip_prefix(reader->line, "unshallow ", &arg)) {
|
||||
if (get_oid_hex(arg, &oid))
|
||||
die(_("invalid unshallow line: %s"), reader->line);
|
||||
if (!lookup_object(oid.hash))
|
||||
if (!lookup_object(the_repository, oid.hash))
|
||||
die(_("object not found: %s"), reader->line);
|
||||
/* make sure that it is parsed as shallow */
|
||||
if (!parse_object(&oid))
|
||||
if (!parse_object(the_repository, &oid))
|
||||
die(_("error in object: %s"), reader->line);
|
||||
if (unregister_shallow(&oid))
|
||||
die(_("no shallow found: %s"), reader->line);
|
||||
|
|
9
fsck.c
9
fsck.c
|
@ -1,5 +1,6 @@
|
|||
#include "cache.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "object.h"
|
||||
#include "blob.h"
|
||||
#include "tree.h"
|
||||
|
@ -413,14 +414,14 @@ static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *op
|
|||
continue;
|
||||
|
||||
if (S_ISDIR(entry.mode)) {
|
||||
obj = (struct object *)lookup_tree(entry.oid);
|
||||
obj = (struct object *)lookup_tree(the_repository, entry.oid);
|
||||
if (name && obj)
|
||||
put_object_name(options, obj, "%s%s/", name,
|
||||
entry.path);
|
||||
result = options->walk(obj, OBJ_TREE, data, options);
|
||||
}
|
||||
else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode)) {
|
||||
obj = (struct object *)lookup_blob(entry.oid);
|
||||
obj = (struct object *)lookup_blob(the_repository, entry.oid);
|
||||
if (name && obj)
|
||||
put_object_name(options, obj, "%s%s", name,
|
||||
entry.path);
|
||||
|
@ -518,7 +519,7 @@ int fsck_walk(struct object *obj, void *data, struct fsck_options *options)
|
|||
return -1;
|
||||
|
||||
if (obj->type == OBJ_NONE)
|
||||
parse_object(&obj->oid);
|
||||
parse_object(the_repository, &obj->oid);
|
||||
|
||||
switch (obj->type) {
|
||||
case OBJ_BLOB:
|
||||
|
@ -1081,7 +1082,7 @@ int fsck_finish(struct fsck_options *options)
|
|||
if (oidset_contains(&gitmodules_done, oid))
|
||||
continue;
|
||||
|
||||
blob = lookup_blob(oid);
|
||||
blob = lookup_blob(the_repository, oid);
|
||||
if (!blob) {
|
||||
struct object *obj = lookup_unknown_object(oid->hash);
|
||||
ret |= report(options, obj,
|
||||
|
|
|
@ -436,13 +436,13 @@ static int show_text_ref(const char *name, const struct object_id *oid,
|
|||
{
|
||||
const char *name_nons = strip_namespace(name);
|
||||
struct strbuf *buf = cb_data;
|
||||
struct object *o = parse_object(oid);
|
||||
struct object *o = parse_object(the_repository, oid);
|
||||
if (!o)
|
||||
return 0;
|
||||
|
||||
strbuf_addf(buf, "%s\t%s\n", oid_to_hex(oid), name_nons);
|
||||
if (o->type == OBJ_TAG) {
|
||||
o = deref_tag(o, name, 0);
|
||||
o = deref_tag(the_repository, o, name, 0);
|
||||
if (!o)
|
||||
return 0;
|
||||
strbuf_addf(buf, "%s\t%s^{}\n", oid_to_hex(&o->oid),
|
||||
|
|
16
http-push.c
16
http-push.c
|
@ -1,4 +1,5 @@
|
|||
#include "cache.h"
|
||||
#include "repository.h"
|
||||
#include "commit.h"
|
||||
#include "tag.h"
|
||||
#include "blob.h"
|
||||
|
@ -14,6 +15,7 @@
|
|||
#include "packfile.h"
|
||||
#include "object-store.h"
|
||||
|
||||
|
||||
#ifdef EXPAT_NEEDS_XMLPARSE_H
|
||||
#include <xmlparse.h>
|
||||
#else
|
||||
|
@ -720,9 +722,9 @@ static void one_remote_object(const struct object_id *oid)
|
|||
{
|
||||
struct object *obj;
|
||||
|
||||
obj = lookup_object(oid->hash);
|
||||
obj = lookup_object(the_repository, oid->hash);
|
||||
if (!obj)
|
||||
obj = parse_object(oid);
|
||||
obj = parse_object(the_repository, oid);
|
||||
|
||||
/* Ignore remote objects that don't exist locally */
|
||||
if (!obj)
|
||||
|
@ -1309,10 +1311,12 @@ static struct object_list **process_tree(struct tree *tree,
|
|||
while (tree_entry(&desc, &entry))
|
||||
switch (object_type(entry.mode)) {
|
||||
case OBJ_TREE:
|
||||
p = process_tree(lookup_tree(entry.oid), p);
|
||||
p = process_tree(lookup_tree(the_repository, entry.oid),
|
||||
p);
|
||||
break;
|
||||
case OBJ_BLOB:
|
||||
p = process_blob(lookup_blob(entry.oid), p);
|
||||
p = process_blob(lookup_blob(the_repository, entry.oid),
|
||||
p);
|
||||
break;
|
||||
default:
|
||||
/* Subproject commit - not in this repository */
|
||||
|
@ -1459,7 +1463,7 @@ static void add_remote_info_ref(struct remote_ls_ctx *ls)
|
|||
return;
|
||||
}
|
||||
|
||||
o = parse_object(&ref->old_oid);
|
||||
o = parse_object(the_repository, &ref->old_oid);
|
||||
if (!o) {
|
||||
fprintf(stderr,
|
||||
"Unable to parse object %s for remote ref %s\n",
|
||||
|
@ -1473,7 +1477,7 @@ static void add_remote_info_ref(struct remote_ls_ctx *ls)
|
|||
oid_to_hex(&ref->old_oid), ls->dentry_name);
|
||||
|
||||
if (o->type == OBJ_TAG) {
|
||||
o = deref_tag(o, ls->dentry_name, 0);
|
||||
o = deref_tag(the_repository, o, ls->dentry_name, 0);
|
||||
if (o)
|
||||
strbuf_addf(buf, "%s\t%s^{}\n",
|
||||
oid_to_hex(&o->oid), ls->dentry_name);
|
||||
|
|
|
@ -479,7 +479,7 @@ static struct commit *check_single_commit(struct rev_info *revs)
|
|||
struct object *obj = revs->pending.objects[i].item;
|
||||
if (obj->flags & UNINTERESTING)
|
||||
continue;
|
||||
obj = deref_tag(obj, NULL, 0);
|
||||
obj = deref_tag(the_repository, obj, NULL, 0);
|
||||
if (obj->type != OBJ_COMMIT)
|
||||
die("Non commit %s?", revs->pending.objects[i].name);
|
||||
if (commit)
|
||||
|
|
|
@ -158,7 +158,7 @@ static void process_tree(struct rev_info *revs,
|
|||
|
||||
if (S_ISDIR(entry.mode))
|
||||
process_tree(revs,
|
||||
lookup_tree(entry.oid),
|
||||
lookup_tree(the_repository, entry.oid),
|
||||
show, base, entry.path,
|
||||
cb_data, filter_fn, filter_data);
|
||||
else if (S_ISGITLINK(entry.mode))
|
||||
|
@ -167,7 +167,7 @@ static void process_tree(struct rev_info *revs,
|
|||
cb_data);
|
||||
else
|
||||
process_blob(revs,
|
||||
lookup_blob(entry.oid),
|
||||
lookup_blob(the_repository, entry.oid),
|
||||
show, base, entry.path,
|
||||
cb_data, filter_fn, filter_data);
|
||||
}
|
||||
|
|
13
log-tree.c
13
log-tree.c
|
@ -2,6 +2,7 @@
|
|||
#include "config.h"
|
||||
#include "diff.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "commit.h"
|
||||
#include "tag.h"
|
||||
#include "graph.h"
|
||||
|
@ -98,13 +99,13 @@ static int add_ref_decoration(const char *refname, const struct object_id *oid,
|
|||
warning("invalid replace ref %s", refname);
|
||||
return 0;
|
||||
}
|
||||
obj = parse_object(&original_oid);
|
||||
obj = parse_object(the_repository, &original_oid);
|
||||
if (obj)
|
||||
add_name_decoration(DECORATION_GRAFTED, "replaced", obj);
|
||||
return 0;
|
||||
}
|
||||
|
||||
obj = parse_object(oid);
|
||||
obj = parse_object(the_repository, oid);
|
||||
if (!obj)
|
||||
return 0;
|
||||
|
||||
|
@ -125,7 +126,7 @@ static int add_ref_decoration(const char *refname, const struct object_id *oid,
|
|||
if (!obj)
|
||||
break;
|
||||
if (!obj->parsed)
|
||||
parse_object(&obj->oid);
|
||||
parse_object(the_repository, &obj->oid);
|
||||
add_name_decoration(DECORATION_REF_TAG, refname, obj);
|
||||
}
|
||||
return 0;
|
||||
|
@ -133,7 +134,7 @@ static int add_ref_decoration(const char *refname, const struct object_id *oid,
|
|||
|
||||
static int add_graft_decoration(const struct commit_graft *graft, void *cb_data)
|
||||
{
|
||||
struct commit *commit = lookup_commit(&graft->oid);
|
||||
struct commit *commit = lookup_commit(the_repository, &graft->oid);
|
||||
if (!commit)
|
||||
return 0;
|
||||
add_name_decoration(DECORATION_GRAFTED, "grafted", &commit->object);
|
||||
|
@ -497,12 +498,12 @@ static int show_one_mergetag(struct commit *commit,
|
|||
size_t payload_size, gpg_message_offset;
|
||||
|
||||
hash_object_file(extra->value, extra->len, type_name(OBJ_TAG), &oid);
|
||||
tag = lookup_tag(&oid);
|
||||
tag = lookup_tag(the_repository, &oid);
|
||||
if (!tag)
|
||||
return -1; /* error message already given */
|
||||
|
||||
strbuf_init(&verify_message, 256);
|
||||
if (parse_tag_buffer(tag, extra->value, extra->len))
|
||||
if (parse_tag_buffer(the_repository, tag, extra->value, extra->len))
|
||||
strbuf_addstr(&verify_message, "malformed mergetag\n");
|
||||
else if (is_common_merge(commit) &&
|
||||
!oidcmp(&tag->tagged->oid,
|
||||
|
|
|
@ -9,6 +9,7 @@
|
|||
#include "lockfile.h"
|
||||
#include "cache-tree.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "commit.h"
|
||||
#include "blob.h"
|
||||
#include "builtin.h"
|
||||
|
@ -157,7 +158,7 @@ static struct tree *shift_tree_object(struct tree *one, struct tree *two,
|
|||
}
|
||||
if (!oidcmp(&two->object.oid, &shifted))
|
||||
return two;
|
||||
return lookup_tree(&shifted);
|
||||
return lookup_tree(the_repository, &shifted);
|
||||
}
|
||||
|
||||
static struct commit *make_virtual_commit(struct tree *tree, const char *comment)
|
||||
|
@ -415,7 +416,7 @@ struct tree *write_tree_from_memory(struct merge_options *o)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
result = lookup_tree(&active_cache_tree->oid);
|
||||
result = lookup_tree(the_repository, &active_cache_tree->oid);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
@ -1191,9 +1192,9 @@ static int merge_submodule(struct merge_options *o,
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (!(commit_base = lookup_commit_reference(base)) ||
|
||||
!(commit_a = lookup_commit_reference(a)) ||
|
||||
!(commit_b = lookup_commit_reference(b))) {
|
||||
if (!(commit_base = lookup_commit_reference(the_repository, base)) ||
|
||||
!(commit_a = lookup_commit_reference(the_repository, a)) ||
|
||||
!(commit_b = lookup_commit_reference(the_repository, b))) {
|
||||
output(o, 1, _("Failed to merge submodule %s (commits not present)"), path);
|
||||
return 0;
|
||||
}
|
||||
|
@ -3426,7 +3427,7 @@ int merge_recursive(struct merge_options *o,
|
|||
/* if there is no common ancestor, use an empty tree */
|
||||
struct tree *tree;
|
||||
|
||||
tree = lookup_tree(the_hash_algo->empty_tree);
|
||||
tree = lookup_tree(the_repository, the_repository->hash_algo->empty_tree);
|
||||
merged_common_ancestors = make_virtual_commit(tree, "ancestor");
|
||||
}
|
||||
|
||||
|
@ -3488,7 +3489,9 @@ static struct commit *get_ref(const struct object_id *oid, const char *name)
|
|||
{
|
||||
struct object *object;
|
||||
|
||||
object = deref_tag(parse_object(oid), name, strlen(name));
|
||||
object = deref_tag(the_repository, parse_object(the_repository, oid),
|
||||
name,
|
||||
strlen(name));
|
||||
if (!object)
|
||||
return NULL;
|
||||
if (object->type == OBJ_TREE)
|
||||
|
|
|
@ -38,7 +38,7 @@ static void rev_list_push(struct negotiation_state *ns,
|
|||
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), refname, 0);
|
||||
struct object *o = deref_tag(the_repository, parse_object(the_repository, oid), refname, 0);
|
||||
|
||||
if (o && o->type == OBJ_COMMIT)
|
||||
clear_commit_marks((struct commit *)o,
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
#include "cache.h"
|
||||
#include "notes-cache.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "commit.h"
|
||||
#include "refs.h"
|
||||
|
||||
|
@ -15,7 +16,7 @@ static int notes_cache_match_validity(const char *ref, const char *validity)
|
|||
if (read_ref(ref, &oid) < 0)
|
||||
return 0;
|
||||
|
||||
commit = lookup_commit_reference_gently(&oid, 1);
|
||||
commit = lookup_commit_reference_gently(the_repository, &oid, 1);
|
||||
if (!commit)
|
||||
return 0;
|
||||
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#include "commit.h"
|
||||
#include "refs.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "diff.h"
|
||||
#include "diffcore.h"
|
||||
#include "xdiff-interface.h"
|
||||
|
@ -553,7 +554,7 @@ int notes_merge(struct notes_merge_options *o,
|
|||
else if (!check_refname_format(o->local_ref, 0) &&
|
||||
is_null_oid(&local_oid))
|
||||
local = NULL; /* local_oid == null_oid indicates unborn ref */
|
||||
else if (!(local = lookup_commit_reference(&local_oid)))
|
||||
else if (!(local = lookup_commit_reference(the_repository, &local_oid)))
|
||||
die("Could not parse local commit %s (%s)",
|
||||
oid_to_hex(&local_oid), o->local_ref);
|
||||
trace_printf("\tlocal commit: %.7s\n", oid_to_hex(&local_oid));
|
||||
|
@ -571,7 +572,7 @@ int notes_merge(struct notes_merge_options *o,
|
|||
die("Failed to resolve remote notes ref '%s'",
|
||||
o->remote_ref);
|
||||
}
|
||||
} else if (!(remote = lookup_commit_reference(&remote_oid))) {
|
||||
} else if (!(remote = lookup_commit_reference(the_repository, &remote_oid))) {
|
||||
die("Could not parse remote commit %s (%s)",
|
||||
oid_to_hex(&remote_oid), o->remote_ref);
|
||||
}
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
#include "commit.h"
|
||||
#include "refs.h"
|
||||
#include "notes-utils.h"
|
||||
#include "repository.h"
|
||||
|
||||
void create_notes_commit(struct notes_tree *t, struct commit_list *parents,
|
||||
const char *msg, size_t msg_len,
|
||||
|
@ -19,7 +20,8 @@ void create_notes_commit(struct notes_tree *t, struct commit_list *parents,
|
|||
/* Deduce parent commit from t->ref */
|
||||
struct object_id parent_oid;
|
||||
if (!read_ref(t->ref, &parent_oid)) {
|
||||
struct commit *parent = lookup_commit(&parent_oid);
|
||||
struct commit *parent = lookup_commit(the_repository,
|
||||
&parent_oid);
|
||||
if (parse_commit(parent))
|
||||
die("Failed to find/parse commit %s", t->ref);
|
||||
commit_list_insert(parent, &parents);
|
||||
|
|
61
object.c
61
object.c
|
@ -84,21 +84,20 @@ static void insert_obj_hash(struct object *obj, struct object **hash, unsigned i
|
|||
* Look up the record for the given sha1 in the hash map stored in
|
||||
* obj_hash. Return NULL if it was not found.
|
||||
*/
|
||||
struct object *lookup_object(const unsigned char *sha1)
|
||||
struct object *lookup_object(struct repository *r, const unsigned char *sha1)
|
||||
{
|
||||
unsigned int i, first;
|
||||
struct object *obj;
|
||||
|
||||
if (!the_repository->parsed_objects->obj_hash)
|
||||
if (!r->parsed_objects->obj_hash)
|
||||
return NULL;
|
||||
|
||||
first = i = hash_obj(sha1,
|
||||
the_repository->parsed_objects->obj_hash_size);
|
||||
while ((obj = the_repository->parsed_objects->obj_hash[i]) != NULL) {
|
||||
first = i = hash_obj(sha1, r->parsed_objects->obj_hash_size);
|
||||
while ((obj = r->parsed_objects->obj_hash[i]) != NULL) {
|
||||
if (!hashcmp(sha1, obj->oid.hash))
|
||||
break;
|
||||
i++;
|
||||
if (i == the_repository->parsed_objects->obj_hash_size)
|
||||
if (i == r->parsed_objects->obj_hash_size)
|
||||
i = 0;
|
||||
}
|
||||
if (obj && i != first) {
|
||||
|
@ -107,8 +106,8 @@ struct object *lookup_object(const unsigned char *sha1)
|
|||
* that we do not need to walk the hash table the next
|
||||
* time we look for it.
|
||||
*/
|
||||
SWAP(the_repository->parsed_objects->obj_hash[i],
|
||||
the_repository->parsed_objects->obj_hash[first]);
|
||||
SWAP(r->parsed_objects->obj_hash[i],
|
||||
r->parsed_objects->obj_hash[first]);
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
@ -158,13 +157,13 @@ void *create_object(struct repository *r, const unsigned char *sha1, void *o)
|
|||
return obj;
|
||||
}
|
||||
|
||||
void *object_as_type(struct object *obj, enum object_type type, int quiet)
|
||||
void *object_as_type(struct repository *r, struct object *obj, enum object_type type, int quiet)
|
||||
{
|
||||
if (obj->type == type)
|
||||
return obj;
|
||||
else if (obj->type == OBJ_NONE) {
|
||||
if (type == OBJ_COMMIT)
|
||||
((struct commit *)obj)->index = alloc_commit_index(the_repository);
|
||||
((struct commit *)obj)->index = alloc_commit_index(r);
|
||||
obj->type = type;
|
||||
return obj;
|
||||
}
|
||||
|
@ -179,28 +178,28 @@ void *object_as_type(struct object *obj, enum object_type type, int quiet)
|
|||
|
||||
struct object *lookup_unknown_object(const unsigned char *sha1)
|
||||
{
|
||||
struct object *obj = lookup_object(sha1);
|
||||
struct object *obj = lookup_object(the_repository, sha1);
|
||||
if (!obj)
|
||||
obj = create_object(the_repository, sha1,
|
||||
alloc_object_node(the_repository));
|
||||
return obj;
|
||||
}
|
||||
|
||||
struct object *parse_object_buffer(const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p)
|
||||
struct object *parse_object_buffer(struct repository *r, const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p)
|
||||
{
|
||||
struct object *obj;
|
||||
*eaten_p = 0;
|
||||
|
||||
obj = NULL;
|
||||
if (type == OBJ_BLOB) {
|
||||
struct blob *blob = lookup_blob(oid);
|
||||
struct blob *blob = lookup_blob(r, oid);
|
||||
if (blob) {
|
||||
if (parse_blob_buffer(blob, buffer, size))
|
||||
return NULL;
|
||||
obj = &blob->object;
|
||||
}
|
||||
} else if (type == OBJ_TREE) {
|
||||
struct tree *tree = lookup_tree(oid);
|
||||
struct tree *tree = lookup_tree(r, oid);
|
||||
if (tree) {
|
||||
obj = &tree->object;
|
||||
if (!tree->buffer)
|
||||
|
@ -212,20 +211,20 @@ struct object *parse_object_buffer(const struct object_id *oid, enum object_type
|
|||
}
|
||||
}
|
||||
} else if (type == OBJ_COMMIT) {
|
||||
struct commit *commit = lookup_commit(oid);
|
||||
struct commit *commit = lookup_commit(r, oid);
|
||||
if (commit) {
|
||||
if (parse_commit_buffer(commit, buffer, size, 1))
|
||||
if (parse_commit_buffer(r, commit, buffer, size, 1))
|
||||
return NULL;
|
||||
if (!get_cached_commit_buffer(commit, NULL)) {
|
||||
set_commit_buffer(commit, buffer, size);
|
||||
if (!get_cached_commit_buffer(r, commit, NULL)) {
|
||||
set_commit_buffer(r, commit, buffer, size);
|
||||
*eaten_p = 1;
|
||||
}
|
||||
obj = &commit->object;
|
||||
}
|
||||
} else if (type == OBJ_TAG) {
|
||||
struct tag *tag = lookup_tag(oid);
|
||||
struct tag *tag = lookup_tag(r, oid);
|
||||
if (tag) {
|
||||
if (parse_tag_buffer(tag, buffer, size))
|
||||
if (parse_tag_buffer(r, tag, buffer, size))
|
||||
return NULL;
|
||||
obj = &tag->object;
|
||||
}
|
||||
|
@ -239,35 +238,35 @@ struct object *parse_object_buffer(const struct object_id *oid, enum object_type
|
|||
struct object *parse_object_or_die(const struct object_id *oid,
|
||||
const char *name)
|
||||
{
|
||||
struct object *o = parse_object(oid);
|
||||
struct object *o = parse_object(the_repository, oid);
|
||||
if (o)
|
||||
return o;
|
||||
|
||||
die(_("unable to parse object: %s"), name ? name : oid_to_hex(oid));
|
||||
}
|
||||
|
||||
struct object *parse_object(const struct object_id *oid)
|
||||
struct object *parse_object(struct repository *r, const struct object_id *oid)
|
||||
{
|
||||
unsigned long size;
|
||||
enum object_type type;
|
||||
int eaten;
|
||||
const struct object_id *repl = lookup_replace_object(the_repository, oid);
|
||||
const struct object_id *repl = lookup_replace_object(r, oid);
|
||||
void *buffer;
|
||||
struct object *obj;
|
||||
|
||||
obj = lookup_object(oid->hash);
|
||||
obj = lookup_object(r, oid->hash);
|
||||
if (obj && obj->parsed)
|
||||
return obj;
|
||||
|
||||
if ((obj && obj->type == OBJ_BLOB && has_object_file(oid)) ||
|
||||
(!obj && has_object_file(oid) &&
|
||||
oid_object_info(the_repository, oid, NULL) == OBJ_BLOB)) {
|
||||
oid_object_info(r, oid, NULL) == OBJ_BLOB)) {
|
||||
if (check_object_signature(repl, NULL, 0, NULL) < 0) {
|
||||
error("sha1 mismatch %s", oid_to_hex(oid));
|
||||
return NULL;
|
||||
}
|
||||
parse_blob_buffer(lookup_blob(oid), NULL, 0);
|
||||
return lookup_object(oid->hash);
|
||||
parse_blob_buffer(lookup_blob(r, oid), NULL, 0);
|
||||
return lookup_object(r, oid->hash);
|
||||
}
|
||||
|
||||
buffer = read_object_file(oid, &type, &size);
|
||||
|
@ -278,7 +277,8 @@ struct object *parse_object(const struct object_id *oid)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
obj = parse_object_buffer(oid, type, size, buffer, &eaten);
|
||||
obj = parse_object_buffer(r, oid, type, size,
|
||||
buffer, &eaten);
|
||||
if (!eaten)
|
||||
free(buffer);
|
||||
return obj;
|
||||
|
@ -467,6 +467,8 @@ struct parsed_object_pool *parsed_object_pool_new(void)
|
|||
o->is_shallow = -1;
|
||||
o->shallow_stat = xcalloc(1, sizeof(*o->shallow_stat));
|
||||
|
||||
o->buffer_slab = allocate_commit_buffer_slab();
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
|
@ -541,6 +543,9 @@ void parsed_object_pool_clear(struct parsed_object_pool *o)
|
|||
FREE_AND_NULL(o->obj_hash);
|
||||
o->obj_hash_size = 0;
|
||||
|
||||
free_commit_buffer_slab(o->buffer_slab);
|
||||
o->buffer_slab = NULL;
|
||||
|
||||
clear_alloc_state(o->blob_state);
|
||||
clear_alloc_state(o->tree_state);
|
||||
clear_alloc_state(o->commit_state);
|
||||
|
|
12
object.h
12
object.h
|
@ -1,6 +1,8 @@
|
|||
#ifndef OBJECT_H
|
||||
#define OBJECT_H
|
||||
|
||||
struct buffer_slab;
|
||||
|
||||
struct parsed_object_pool {
|
||||
struct object **obj_hash;
|
||||
int nr_objs, obj_hash_size;
|
||||
|
@ -22,6 +24,8 @@ struct parsed_object_pool {
|
|||
char *alternate_shallow_file;
|
||||
|
||||
int commit_graft_prepared;
|
||||
|
||||
struct buffer_slab *buffer_slab;
|
||||
};
|
||||
|
||||
struct parsed_object_pool *parsed_object_pool_new(void);
|
||||
|
@ -110,18 +114,18 @@ extern struct object *get_indexed_object(unsigned int);
|
|||
* half-initialised objects, the caller is expected to initialize them
|
||||
* by calling parse_object() on them.
|
||||
*/
|
||||
struct object *lookup_object(const unsigned char *sha1);
|
||||
struct object *lookup_object(struct repository *r, const unsigned char *sha1);
|
||||
|
||||
extern void *create_object(struct repository *r, const unsigned char *sha1, void *obj);
|
||||
|
||||
void *object_as_type(struct object *obj, enum object_type type, int quiet);
|
||||
void *object_as_type(struct repository *r, struct object *obj, enum object_type type, int quiet);
|
||||
|
||||
/*
|
||||
* Returns the object, having parsed it to find out what it is.
|
||||
*
|
||||
* Returns NULL if the object is missing or corrupt.
|
||||
*/
|
||||
struct object *parse_object(const struct object_id *oid);
|
||||
struct object *parse_object(struct repository *r, const struct object_id *oid);
|
||||
|
||||
/*
|
||||
* Like parse_object, but will die() instead of returning NULL. If the
|
||||
|
@ -134,7 +138,7 @@ struct object *parse_object_or_die(const struct object_id *oid, const char *name
|
|||
* parsing it. eaten_p indicates if the object has a borrowed copy
|
||||
* of buffer and the caller should not free() it.
|
||||
*/
|
||||
struct object *parse_object_buffer(const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p);
|
||||
struct object *parse_object_buffer(struct repository *r, const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p);
|
||||
|
||||
/** Returns the object, with potentially excess memory allocated. **/
|
||||
struct object *lookup_unknown_object(const unsigned char *sha1);
|
||||
|
|
|
@ -1934,7 +1934,7 @@ static int add_promisor_object(const struct object_id *oid,
|
|||
void *set_)
|
||||
{
|
||||
struct oidset *set = set_;
|
||||
struct object *obj = parse_object(oid);
|
||||
struct object *obj = parse_object(the_repository, oid);
|
||||
if (!obj)
|
||||
return 1;
|
||||
|
||||
|
|
|
@ -91,7 +91,7 @@ int parse_opt_commits(const struct option *opt, const char *arg, int unset)
|
|||
return -1;
|
||||
if (get_oid(arg, &oid))
|
||||
return error("malformed object name %s", arg);
|
||||
commit = lookup_commit_reference(&oid);
|
||||
commit = lookup_commit_reference(the_repository, &oid);
|
||||
if (!commit)
|
||||
return error("no such commit %s", arg);
|
||||
commit_list_insert(commit, opt->value);
|
||||
|
|
4
pretty.c
4
pretty.c
|
@ -630,7 +630,7 @@ const char *logmsg_reencode(const struct commit *commit,
|
|||
* the cached copy from get_commit_buffer, we need to duplicate it
|
||||
* to avoid munging the cached copy.
|
||||
*/
|
||||
if (msg == get_cached_commit_buffer(commit, NULL))
|
||||
if (msg == get_cached_commit_buffer(the_repository, commit, NULL))
|
||||
out = xstrdup(msg);
|
||||
else
|
||||
out = (char *)msg;
|
||||
|
@ -1146,7 +1146,7 @@ static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
|
|||
|
||||
/* these depend on the commit */
|
||||
if (!commit->object.parsed)
|
||||
parse_object(&commit->object.oid);
|
||||
parse_object(the_repository, &commit->object.oid);
|
||||
|
||||
switch (placeholder[0]) {
|
||||
case 'H': /* commit hash */
|
||||
|
|
|
@ -88,10 +88,10 @@ static void add_recent_object(const struct object_id *oid,
|
|||
obj = parse_object_or_die(oid, NULL);
|
||||
break;
|
||||
case OBJ_TREE:
|
||||
obj = (struct object *)lookup_tree(oid);
|
||||
obj = (struct object *)lookup_tree(the_repository, oid);
|
||||
break;
|
||||
case OBJ_BLOB:
|
||||
obj = (struct object *)lookup_blob(oid);
|
||||
obj = (struct object *)lookup_blob(the_repository, oid);
|
||||
break;
|
||||
default:
|
||||
die("unknown object type for %s: %s",
|
||||
|
@ -108,7 +108,7 @@ static int add_recent_loose(const struct object_id *oid,
|
|||
const char *path, void *data)
|
||||
{
|
||||
struct stat st;
|
||||
struct object *obj = lookup_object(oid->hash);
|
||||
struct object *obj = lookup_object(the_repository, oid->hash);
|
||||
|
||||
if (obj && obj->flags & SEEN)
|
||||
return 0;
|
||||
|
@ -133,7 +133,7 @@ static int add_recent_packed(const struct object_id *oid,
|
|||
struct packed_git *p, uint32_t pos,
|
||||
void *data)
|
||||
{
|
||||
struct object *obj = lookup_object(oid->hash);
|
||||
struct object *obj = lookup_object(the_repository, oid->hash);
|
||||
|
||||
if (obj && obj->flags & SEEN)
|
||||
return 0;
|
||||
|
|
12
ref-filter.c
12
ref-filter.c
|
@ -4,6 +4,7 @@
|
|||
#include "refs.h"
|
||||
#include "wildmatch.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "commit.h"
|
||||
#include "remote.h"
|
||||
#include "color.h"
|
||||
|
@ -806,7 +807,8 @@ static void *get_obj(const struct object_id *oid, struct object **obj, unsigned
|
|||
void *buf = read_object_file(oid, &type, sz);
|
||||
|
||||
if (buf)
|
||||
*obj = parse_object_buffer(oid, type, *sz, buf, eaten);
|
||||
*obj = parse_object_buffer(the_repository, oid, type, *sz,
|
||||
buf, eaten);
|
||||
else
|
||||
*obj = NULL;
|
||||
return buf;
|
||||
|
@ -1923,7 +1925,7 @@ static const struct object_id *match_points_at(struct oid_array *points_at,
|
|||
|
||||
if (oid_array_lookup(points_at, oid) >= 0)
|
||||
return oid;
|
||||
obj = parse_object(oid);
|
||||
obj = parse_object(the_repository, oid);
|
||||
if (!obj)
|
||||
die(_("malformed object at '%s'"), refname);
|
||||
if (obj->type == OBJ_TAG)
|
||||
|
@ -2033,7 +2035,8 @@ static int ref_filter_handler(const char *refname, const struct object_id *oid,
|
|||
* non-commits early. The actual filtering is done later.
|
||||
*/
|
||||
if (filter->merge_commit || filter->with_commit || filter->no_commit || filter->verbose) {
|
||||
commit = lookup_commit_reference_gently(oid, 1);
|
||||
commit = lookup_commit_reference_gently(the_repository, oid,
|
||||
1);
|
||||
if (!commit)
|
||||
return 0;
|
||||
/* We perform the filtering for the '--contains' option... */
|
||||
|
@ -2390,7 +2393,8 @@ int parse_opt_merge_filter(const struct option *opt, const char *arg, int unset)
|
|||
if (get_oid(arg, &oid))
|
||||
die(_("malformed object name %s"), arg);
|
||||
|
||||
rf->merge_commit = lookup_commit_reference_gently(&oid, 0);
|
||||
rf->merge_commit = lookup_commit_reference_gently(the_repository,
|
||||
&oid, 0);
|
||||
if (!rf->merge_commit)
|
||||
return opterror(opt, "must point to a commit", 0);
|
||||
|
||||
|
|
|
@ -305,7 +305,8 @@ static struct commit *next_reflog_commit(struct commit_reflog *log)
|
|||
{
|
||||
for (; log->recno >= 0; log->recno--) {
|
||||
struct reflog_info *entry = &log->reflogs->items[log->recno];
|
||||
struct object *obj = parse_object(&entry->noid);
|
||||
struct object *obj = parse_object(the_repository,
|
||||
&entry->noid);
|
||||
|
||||
if (obj && obj->type == OBJ_COMMIT)
|
||||
return (struct commit *)obj;
|
||||
|
|
2
refs.c
2
refs.c
|
@ -305,7 +305,7 @@ enum peel_status peel_object(const struct object_id *name, struct object_id *oid
|
|||
|
||||
if (o->type == OBJ_NONE) {
|
||||
int type = oid_object_info(the_repository, name, NULL);
|
||||
if (type < 0 || !object_as_type(o, type, 0))
|
||||
if (type < 0 || !object_as_type(the_repository, o, type, 0))
|
||||
return PEEL_INVALID;
|
||||
}
|
||||
|
||||
|
|
|
@ -1651,7 +1651,7 @@ static int write_ref_to_lockfile(struct ref_lock *lock,
|
|||
struct object *o;
|
||||
int fd;
|
||||
|
||||
o = parse_object(oid);
|
||||
o = parse_object(the_repository, oid);
|
||||
if (!o) {
|
||||
strbuf_addf(err,
|
||||
"trying to write ref '%s' with nonexistent object %s",
|
||||
|
|
19
remote.c
19
remote.c
|
@ -1149,7 +1149,7 @@ static void add_to_tips(struct tips *tips, const struct object_id *oid)
|
|||
|
||||
if (is_null_oid(oid))
|
||||
return;
|
||||
commit = lookup_commit_reference_gently(oid, 1);
|
||||
commit = lookup_commit_reference_gently(the_repository, oid, 1);
|
||||
if (!commit || (commit->object.flags & TMP_MARK))
|
||||
return;
|
||||
commit->object.flags |= TMP_MARK;
|
||||
|
@ -1211,7 +1211,8 @@ static void add_missing_tags(struct ref *src, struct ref **dst, struct ref ***ds
|
|||
|
||||
if (is_null_oid(&ref->new_oid))
|
||||
continue;
|
||||
commit = lookup_commit_reference_gently(&ref->new_oid,
|
||||
commit = lookup_commit_reference_gently(the_repository,
|
||||
&ref->new_oid,
|
||||
1);
|
||||
if (!commit)
|
||||
/* not pushing a commit, which is not an error */
|
||||
|
@ -1435,8 +1436,8 @@ void set_ref_status_for_push(struct ref *remote_refs, int send_mirror,
|
|||
reject_reason = REF_STATUS_REJECT_ALREADY_EXISTS;
|
||||
else if (!has_object_file(&ref->old_oid))
|
||||
reject_reason = REF_STATUS_REJECT_FETCH_FIRST;
|
||||
else if (!lookup_commit_reference_gently(&ref->old_oid, 1) ||
|
||||
!lookup_commit_reference_gently(&ref->new_oid, 1))
|
||||
else if (!lookup_commit_reference_gently(the_repository, &ref->old_oid, 1) ||
|
||||
!lookup_commit_reference_gently(the_repository, &ref->new_oid, 1))
|
||||
reject_reason = REF_STATUS_REJECT_NEEDS_FORCE;
|
||||
else if (!ref_newer(&ref->new_oid, &ref->old_oid))
|
||||
reject_reason = REF_STATUS_REJECT_NONFASTFORWARD;
|
||||
|
@ -1802,12 +1803,14 @@ int ref_newer(const struct object_id *new_oid, const struct object_id *old_oid)
|
|||
* Both new_commit and old_commit must be commit-ish and new_commit is descendant of
|
||||
* old_commit. Otherwise we require --force.
|
||||
*/
|
||||
o = deref_tag(parse_object(old_oid), NULL, 0);
|
||||
o = deref_tag(the_repository, parse_object(the_repository, old_oid),
|
||||
NULL, 0);
|
||||
if (!o || o->type != OBJ_COMMIT)
|
||||
return 0;
|
||||
old_commit = (struct commit *) o;
|
||||
|
||||
o = deref_tag(parse_object(new_oid), NULL, 0);
|
||||
o = deref_tag(the_repository, parse_object(the_repository, new_oid),
|
||||
NULL, 0);
|
||||
if (!o || o->type != OBJ_COMMIT)
|
||||
return 0;
|
||||
new_commit = (struct commit *) o;
|
||||
|
@ -1865,13 +1868,13 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
|
|||
/* Cannot stat if what we used to build on no longer exists */
|
||||
if (read_ref(base, &oid))
|
||||
return -1;
|
||||
theirs = lookup_commit_reference(&oid);
|
||||
theirs = lookup_commit_reference(the_repository, &oid);
|
||||
if (!theirs)
|
||||
return -1;
|
||||
|
||||
if (read_ref(branch->refname, &oid))
|
||||
return -1;
|
||||
ours = lookup_commit_reference(&oid);
|
||||
ours = lookup_commit_reference(the_repository, &oid);
|
||||
if (!ours)
|
||||
return -1;
|
||||
|
||||
|
|
26
revision.c
26
revision.c
|
@ -63,10 +63,10 @@ static void mark_tree_contents_uninteresting(struct tree *tree)
|
|||
while (tree_entry(&desc, &entry)) {
|
||||
switch (object_type(entry.mode)) {
|
||||
case OBJ_TREE:
|
||||
mark_tree_uninteresting(lookup_tree(entry.oid));
|
||||
mark_tree_uninteresting(lookup_tree(the_repository, entry.oid));
|
||||
break;
|
||||
case OBJ_BLOB:
|
||||
mark_blob_uninteresting(lookup_blob(entry.oid));
|
||||
mark_blob_uninteresting(lookup_blob(the_repository, entry.oid));
|
||||
break;
|
||||
default:
|
||||
/* Subproject commit - not in this repository */
|
||||
|
@ -198,7 +198,7 @@ void add_head_to_pending(struct rev_info *revs)
|
|||
struct object *obj;
|
||||
if (get_oid("HEAD", &oid))
|
||||
return;
|
||||
obj = parse_object(&oid);
|
||||
obj = parse_object(the_repository, &oid);
|
||||
if (!obj)
|
||||
return;
|
||||
add_pending_object(revs, obj, "HEAD");
|
||||
|
@ -210,7 +210,7 @@ static struct object *get_reference(struct rev_info *revs, const char *name,
|
|||
{
|
||||
struct object *object;
|
||||
|
||||
object = parse_object(oid);
|
||||
object = parse_object(the_repository, oid);
|
||||
if (!object) {
|
||||
if (revs->ignore_missing)
|
||||
return object;
|
||||
|
@ -247,7 +247,7 @@ static struct commit *handle_commit(struct rev_info *revs,
|
|||
add_pending_object(revs, object, tag->tag);
|
||||
if (!tag->tagged)
|
||||
die("bad tag");
|
||||
object = parse_object(&tag->tagged->oid);
|
||||
object = parse_object(the_repository, &tag->tagged->oid);
|
||||
if (!object) {
|
||||
if (revs->ignore_missing_links || (flags & UNINTERESTING))
|
||||
return NULL;
|
||||
|
@ -1250,7 +1250,7 @@ static void handle_one_reflog_commit(struct object_id *oid, void *cb_data)
|
|||
{
|
||||
struct all_refs_cb *cb = cb_data;
|
||||
if (!is_null_oid(oid)) {
|
||||
struct object *o = parse_object(oid);
|
||||
struct object *o = parse_object(the_repository, oid);
|
||||
if (o) {
|
||||
o->flags |= cb->all_flags;
|
||||
/* ??? CMDLINEFLAGS ??? */
|
||||
|
@ -1323,7 +1323,7 @@ static void add_cache_tree(struct cache_tree *it, struct rev_info *revs,
|
|||
int i;
|
||||
|
||||
if (it->entry_count >= 0) {
|
||||
struct tree *tree = lookup_tree(&it->oid);
|
||||
struct tree *tree = lookup_tree(the_repository, &it->oid);
|
||||
add_pending_object_with_path(revs, &tree->object, "",
|
||||
040000, path->buf);
|
||||
}
|
||||
|
@ -1349,7 +1349,7 @@ static void do_add_index_objects_to_pending(struct rev_info *revs,
|
|||
if (S_ISGITLINK(ce->ce_mode))
|
||||
continue;
|
||||
|
||||
blob = lookup_blob(&ce->oid);
|
||||
blob = lookup_blob(the_repository, &ce->oid);
|
||||
if (!blob)
|
||||
die("unable to add index blob to traversal");
|
||||
add_pending_object_with_path(revs, &blob->object, "",
|
||||
|
@ -1578,8 +1578,8 @@ static int handle_dotdot_1(const char *arg, char *dotdot,
|
|||
*dotdot = '\0';
|
||||
}
|
||||
|
||||
a_obj = parse_object(&a_oid);
|
||||
b_obj = parse_object(&b_oid);
|
||||
a_obj = parse_object(the_repository, &a_oid);
|
||||
b_obj = parse_object(the_repository, &b_oid);
|
||||
if (!a_obj || !b_obj)
|
||||
return dotdot_missing(arg, dotdot, revs, symmetric);
|
||||
|
||||
|
@ -1592,8 +1592,8 @@ static int handle_dotdot_1(const char *arg, char *dotdot,
|
|||
struct commit *a, *b;
|
||||
struct commit_list *exclude;
|
||||
|
||||
a = lookup_commit_reference(&a_obj->oid);
|
||||
b = lookup_commit_reference(&b_obj->oid);
|
||||
a = lookup_commit_reference(the_repository, &a_obj->oid);
|
||||
b = lookup_commit_reference(the_repository, &b_obj->oid);
|
||||
if (!a || !b)
|
||||
return dotdot_missing(arg, dotdot, revs, symmetric);
|
||||
|
||||
|
@ -2884,7 +2884,7 @@ static int mark_uninteresting(const struct object_id *oid,
|
|||
uint32_t pos,
|
||||
void *unused)
|
||||
{
|
||||
struct object *o = parse_object(oid);
|
||||
struct object *o = parse_object(the_repository, oid);
|
||||
o->flags |= UNINTERESTING | SEEN;
|
||||
return 0;
|
||||
}
|
||||
|
|
14
sequencer.c
14
sequencer.c
|
@ -433,7 +433,7 @@ static int read_oneliner(struct strbuf *buf,
|
|||
|
||||
static struct tree *empty_tree(void)
|
||||
{
|
||||
return lookup_tree(the_hash_algo->empty_tree);
|
||||
return lookup_tree(the_repository, the_repository->hash_algo->empty_tree);
|
||||
}
|
||||
|
||||
static int error_dirty_index(struct replay_opts *opts)
|
||||
|
@ -594,7 +594,7 @@ static int is_index_unchanged(void)
|
|||
if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
|
||||
return error(_("could not resolve HEAD commit"));
|
||||
|
||||
head_commit = lookup_commit(&head_oid);
|
||||
head_commit = lookup_commit(the_repository, &head_oid);
|
||||
|
||||
/*
|
||||
* If head_commit is NULL, check_commit, called from
|
||||
|
@ -1101,7 +1101,7 @@ void print_commit_summary(const char *prefix, const struct object_id *oid,
|
|||
struct strbuf author_ident = STRBUF_INIT;
|
||||
struct strbuf committer_ident = STRBUF_INIT;
|
||||
|
||||
commit = lookup_commit(oid);
|
||||
commit = lookup_commit(the_repository, oid);
|
||||
if (!commit)
|
||||
die(_("couldn't look up newly created commit"));
|
||||
if (parse_commit(commit))
|
||||
|
@ -1176,7 +1176,7 @@ static int parse_head(struct commit **head)
|
|||
if (get_oid("HEAD", &oid)) {
|
||||
current_head = NULL;
|
||||
} else {
|
||||
current_head = lookup_commit_reference(&oid);
|
||||
current_head = lookup_commit_reference(the_repository, &oid);
|
||||
if (!current_head)
|
||||
return error(_("could not parse HEAD"));
|
||||
if (oidcmp(&oid, ¤t_head->object.oid)) {
|
||||
|
@ -1511,7 +1511,7 @@ static int update_squash_messages(enum todo_command command,
|
|||
|
||||
if (get_oid("HEAD", &head))
|
||||
return error(_("need a HEAD to fixup"));
|
||||
if (!(head_commit = lookup_commit_reference(&head)))
|
||||
if (!(head_commit = lookup_commit_reference(the_repository, &head)))
|
||||
return error(_("could not read HEAD"));
|
||||
if (!(head_message = get_commit_buffer(head_commit, NULL)))
|
||||
return error(_("could not read HEAD's commit message"));
|
||||
|
@ -2007,7 +2007,7 @@ static int parse_insn_line(struct todo_item *item, const char *bol, char *eol)
|
|||
if (status < 0)
|
||||
return -1;
|
||||
|
||||
item->commit = lookup_commit_reference(&commit_oid);
|
||||
item->commit = lookup_commit_reference(the_repository, &commit_oid);
|
||||
return !item->commit;
|
||||
}
|
||||
|
||||
|
@ -3634,7 +3634,7 @@ int sequencer_pick_revisions(struct replay_opts *opts)
|
|||
continue;
|
||||
|
||||
if (!get_oid(name, &oid)) {
|
||||
if (!lookup_commit_reference_gently(&oid, 1)) {
|
||||
if (!lookup_commit_reference_gently(the_repository, &oid, 1)) {
|
||||
enum object_type type = oid_object_info(the_repository,
|
||||
&oid,
|
||||
NULL);
|
||||
|
|
|
@ -56,7 +56,7 @@ 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(oid);
|
||||
struct object *o = parse_object(the_repository, oid);
|
||||
if (!o)
|
||||
return -1;
|
||||
|
||||
|
@ -64,7 +64,7 @@ static int add_info_ref(const char *path, const struct object_id *oid,
|
|||
return -1;
|
||||
|
||||
if (o->type == OBJ_TAG) {
|
||||
o = deref_tag(o, path, 0);
|
||||
o = deref_tag(the_repository, o, path, 0);
|
||||
if (o)
|
||||
if (fprintf(fp, "%s %s^{}\n",
|
||||
oid_to_hex(&o->oid), path) < 0)
|
||||
|
|
|
@ -1801,7 +1801,7 @@ static void check_commit(const void *buf, size_t size)
|
|||
{
|
||||
struct commit c;
|
||||
memset(&c, 0, sizeof(c));
|
||||
if (parse_commit_buffer(&c, buf, size, 0))
|
||||
if (parse_commit_buffer(the_repository, &c, buf, size, 0))
|
||||
die("corrupt commit");
|
||||
}
|
||||
|
||||
|
@ -1809,7 +1809,7 @@ static void check_tag(const void *buf, size_t size)
|
|||
{
|
||||
struct tag t;
|
||||
memset(&t, 0, sizeof(t));
|
||||
if (parse_tag_buffer(&t, buf, size))
|
||||
if (parse_tag_buffer(the_repository, &t, buf, size))
|
||||
die("corrupt tag");
|
||||
}
|
||||
|
||||
|
|
33
sha1-name.c
33
sha1-name.c
|
@ -239,7 +239,8 @@ static int disambiguate_committish_only(const struct object_id *oid, void *cb_da
|
|||
return 0;
|
||||
|
||||
/* We need to do this the hard way... */
|
||||
obj = deref_tag(parse_object(oid), NULL, 0);
|
||||
obj = deref_tag(the_repository, parse_object(the_repository, oid),
|
||||
NULL, 0);
|
||||
if (obj && obj->type == OBJ_COMMIT)
|
||||
return 1;
|
||||
return 0;
|
||||
|
@ -263,7 +264,8 @@ static int disambiguate_treeish_only(const struct object_id *oid, void *cb_data_
|
|||
return 0;
|
||||
|
||||
/* We need to do this the hard way... */
|
||||
obj = deref_tag(parse_object(oid), NULL, 0);
|
||||
obj = deref_tag(the_repository, parse_object(the_repository, oid),
|
||||
NULL, 0);
|
||||
if (obj && (obj->type == OBJ_TREE || obj->type == OBJ_COMMIT))
|
||||
return 1;
|
||||
return 0;
|
||||
|
@ -351,14 +353,14 @@ static int show_ambiguous_object(const struct object_id *oid, void *data)
|
|||
|
||||
type = oid_object_info(the_repository, oid, NULL);
|
||||
if (type == OBJ_COMMIT) {
|
||||
struct commit *commit = lookup_commit(oid);
|
||||
struct commit *commit = lookup_commit(the_repository, oid);
|
||||
if (commit) {
|
||||
struct pretty_print_context pp = {0};
|
||||
pp.date_mode.type = DATE_SHORT;
|
||||
format_commit_message(commit, " %ad - %s", &desc, &pp);
|
||||
}
|
||||
} else if (type == OBJ_TAG) {
|
||||
struct tag *tag = lookup_tag(oid);
|
||||
struct tag *tag = lookup_tag(the_repository, oid);
|
||||
if (!parse_tag(tag) && tag->tag)
|
||||
strbuf_addf(&desc, " %s", tag->tag);
|
||||
}
|
||||
|
@ -846,7 +848,7 @@ static int get_parent(const char *name, int len,
|
|||
|
||||
if (ret)
|
||||
return ret;
|
||||
commit = lookup_commit_reference(&oid);
|
||||
commit = lookup_commit_reference(the_repository, &oid);
|
||||
if (parse_commit(commit))
|
||||
return -1;
|
||||
if (!idx) {
|
||||
|
@ -874,7 +876,7 @@ static int get_nth_ancestor(const char *name, int len,
|
|||
ret = get_oid_1(name, len, &oid, GET_OID_COMMITTISH);
|
||||
if (ret)
|
||||
return ret;
|
||||
commit = lookup_commit_reference(&oid);
|
||||
commit = lookup_commit_reference(the_repository, &oid);
|
||||
if (!commit)
|
||||
return -1;
|
||||
|
||||
|
@ -893,7 +895,7 @@ struct object *peel_to_type(const char *name, int namelen,
|
|||
if (name && !namelen)
|
||||
namelen = strlen(name);
|
||||
while (1) {
|
||||
if (!o || (!o->parsed && !parse_object(&o->oid)))
|
||||
if (!o || (!o->parsed && !parse_object(the_repository, &o->oid)))
|
||||
return NULL;
|
||||
if (expected_type == OBJ_ANY || o->type == expected_type)
|
||||
return o;
|
||||
|
@ -966,12 +968,12 @@ static int peel_onion(const char *name, int len, struct object_id *oid,
|
|||
if (get_oid_1(name, sp - name - 2, &outer, lookup_flags))
|
||||
return -1;
|
||||
|
||||
o = parse_object(&outer);
|
||||
o = parse_object(the_repository, &outer);
|
||||
if (!o)
|
||||
return -1;
|
||||
if (!expected_type) {
|
||||
o = deref_tag(o, name, sp - name - 2);
|
||||
if (!o || (!o->parsed && !parse_object(&o->oid)))
|
||||
o = deref_tag(the_repository, o, name, sp - name - 2);
|
||||
if (!o || (!o->parsed && !parse_object(the_repository, &o->oid)))
|
||||
return -1;
|
||||
oidcpy(oid, &o->oid);
|
||||
return 0;
|
||||
|
@ -1098,11 +1100,12 @@ 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(oid);
|
||||
struct object *object = parse_object(the_repository, oid);
|
||||
if (!object)
|
||||
return 0;
|
||||
if (object->type == OBJ_TAG) {
|
||||
object = deref_tag(object, path, strlen(path));
|
||||
object = deref_tag(the_repository, object, path,
|
||||
strlen(path));
|
||||
if (!object)
|
||||
return 0;
|
||||
}
|
||||
|
@ -1144,7 +1147,7 @@ static int get_oid_oneline(const char *prefix, struct object_id *oid,
|
|||
int matches;
|
||||
|
||||
commit = pop_most_recent_commit(&list, ONELINE_SEEN);
|
||||
if (!parse_object(&commit->object.oid))
|
||||
if (!parse_object(the_repository, &commit->object.oid))
|
||||
continue;
|
||||
buf = get_commit_buffer(commit, NULL);
|
||||
p = strstr(buf, "\n\n");
|
||||
|
@ -1253,13 +1256,13 @@ int get_oid_mb(const char *name, struct object_id *oid)
|
|||
}
|
||||
if (st)
|
||||
return st;
|
||||
one = lookup_commit_reference_gently(&oid_tmp, 0);
|
||||
one = lookup_commit_reference_gently(the_repository, &oid_tmp, 0);
|
||||
if (!one)
|
||||
return -1;
|
||||
|
||||
if (get_oid_committish(dots[3] ? (dots + 3) : "HEAD", &oid_tmp))
|
||||
return -1;
|
||||
two = lookup_commit_reference_gently(&oid_tmp, 0);
|
||||
two = lookup_commit_reference_gently(the_repository, &oid_tmp, 0);
|
||||
if (!two)
|
||||
return -1;
|
||||
mbs = get_merge_bases(one, two);
|
||||
|
|
30
shallow.c
30
shallow.c
|
@ -31,7 +31,7 @@ int register_shallow(struct repository *r, const struct object_id *oid)
|
|||
{
|
||||
struct commit_graft *graft =
|
||||
xmalloc(sizeof(struct commit_graft));
|
||||
struct commit *commit = lookup_commit(oid);
|
||||
struct commit *commit = lookup_commit(the_repository, oid);
|
||||
|
||||
oidcpy(&graft->oid, oid);
|
||||
graft->nr_parent = -1;
|
||||
|
@ -96,7 +96,9 @@ struct commit_list *get_shallow_commits(struct object_array *heads, int depth,
|
|||
if (i < heads->nr) {
|
||||
int **depth_slot;
|
||||
commit = (struct commit *)
|
||||
deref_tag(heads->objects[i++].item, NULL, 0);
|
||||
deref_tag(the_repository,
|
||||
heads->objects[i++].item,
|
||||
NULL, 0);
|
||||
if (!commit || commit->object.type != OBJ_COMMIT) {
|
||||
commit = NULL;
|
||||
continue;
|
||||
|
@ -259,7 +261,7 @@ static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
|
|||
if (graft->nr_parent != -1)
|
||||
return 0;
|
||||
if (data->flags & SEEN_ONLY) {
|
||||
struct commit *c = lookup_commit(&graft->oid);
|
||||
struct commit *c = lookup_commit(the_repository, &graft->oid);
|
||||
if (!c || !(c->object.flags & SEEN)) {
|
||||
if (data->flags & VERBOSE)
|
||||
printf("Removing %s from .git/shallow\n",
|
||||
|
@ -492,7 +494,8 @@ static void paint_down(struct paint_info *info, const struct object_id *oid,
|
|||
struct commit_list *head = NULL;
|
||||
int bitmap_nr = DIV_ROUND_UP(info->nr_bits, 32);
|
||||
size_t bitmap_size = st_mult(sizeof(uint32_t), bitmap_nr);
|
||||
struct commit *c = lookup_commit_reference_gently(oid, 1);
|
||||
struct commit *c = lookup_commit_reference_gently(the_repository, oid,
|
||||
1);
|
||||
uint32_t *tmp; /* to be freed before return */
|
||||
uint32_t *bitmap;
|
||||
|
||||
|
@ -554,7 +557,8 @@ static void paint_down(struct paint_info *info, const struct object_id *oid,
|
|||
static int mark_uninteresting(const char *refname, const struct object_id *oid,
|
||||
int flags, void *cb_data)
|
||||
{
|
||||
struct commit *commit = lookup_commit_reference_gently(oid, 1);
|
||||
struct commit *commit = lookup_commit_reference_gently(the_repository,
|
||||
oid, 1);
|
||||
if (!commit)
|
||||
return 0;
|
||||
commit->object.flags |= UNINTERESTING;
|
||||
|
@ -622,7 +626,8 @@ void assign_shallow_commits_to_refs(struct shallow_info *info,
|
|||
|
||||
/* Mark potential bottoms so we won't go out of bound */
|
||||
for (i = 0; i < nr_shallow; i++) {
|
||||
struct commit *c = lookup_commit(&oid[shallow[i]]);
|
||||
struct commit *c = lookup_commit(the_repository,
|
||||
&oid[shallow[i]]);
|
||||
c->object.flags |= BOTTOM;
|
||||
}
|
||||
|
||||
|
@ -633,7 +638,8 @@ void assign_shallow_commits_to_refs(struct shallow_info *info,
|
|||
int bitmap_size = DIV_ROUND_UP(pi.nr_bits, 32) * sizeof(uint32_t);
|
||||
memset(used, 0, sizeof(*used) * info->shallow->nr);
|
||||
for (i = 0; i < nr_shallow; i++) {
|
||||
const struct commit *c = lookup_commit(&oid[shallow[i]]);
|
||||
const struct commit *c = lookup_commit(the_repository,
|
||||
&oid[shallow[i]]);
|
||||
uint32_t **map = ref_bitmap_at(&pi.ref_bitmap, c);
|
||||
if (*map)
|
||||
used[shallow[i]] = xmemdupz(*map, bitmap_size);
|
||||
|
@ -664,7 +670,8 @@ static int add_ref(const char *refname, const struct object_id *oid,
|
|||
{
|
||||
struct commit_array *ca = cb_data;
|
||||
ALLOC_GROW(ca->commits, ca->nr + 1, ca->alloc);
|
||||
ca->commits[ca->nr] = lookup_commit_reference_gently(oid, 1);
|
||||
ca->commits[ca->nr] = lookup_commit_reference_gently(the_repository,
|
||||
oid, 1);
|
||||
if (ca->commits[ca->nr])
|
||||
ca->nr++;
|
||||
return 0;
|
||||
|
@ -702,7 +709,7 @@ static void post_assign_shallow(struct shallow_info *info,
|
|||
for (i = dst = 0; i < info->nr_theirs; i++) {
|
||||
if (i != dst)
|
||||
info->theirs[dst] = info->theirs[i];
|
||||
c = lookup_commit(&oid[info->theirs[i]]);
|
||||
c = lookup_commit(the_repository, &oid[info->theirs[i]]);
|
||||
bitmap = ref_bitmap_at(ref_bitmap, c);
|
||||
if (!*bitmap)
|
||||
continue;
|
||||
|
@ -723,7 +730,7 @@ static void post_assign_shallow(struct shallow_info *info,
|
|||
for (i = dst = 0; i < info->nr_ours; i++) {
|
||||
if (i != dst)
|
||||
info->ours[dst] = info->ours[i];
|
||||
c = lookup_commit(&oid[info->ours[i]]);
|
||||
c = lookup_commit(the_repository, &oid[info->ours[i]]);
|
||||
bitmap = ref_bitmap_at(ref_bitmap, c);
|
||||
if (!*bitmap)
|
||||
continue;
|
||||
|
@ -745,7 +752,8 @@ static void post_assign_shallow(struct shallow_info *info,
|
|||
int delayed_reachability_test(struct shallow_info *si, int c)
|
||||
{
|
||||
if (si->need_reachability_test[c]) {
|
||||
struct commit *commit = lookup_commit(&si->shallow->oid[c]);
|
||||
struct commit *commit = lookup_commit(the_repository,
|
||||
&si->shallow->oid[c]);
|
||||
|
||||
if (!si->commits) {
|
||||
struct commit_array ca;
|
||||
|
|
|
@ -517,8 +517,8 @@ static void show_submodule_header(struct diff_options *o, const char *path,
|
|||
* Attempt to lookup the commit references, and determine if this is
|
||||
* a fast forward or fast backwards update.
|
||||
*/
|
||||
*left = lookup_commit_reference(one);
|
||||
*right = lookup_commit_reference(two);
|
||||
*left = lookup_commit_reference(the_repository, one);
|
||||
*right = lookup_commit_reference(the_repository, two);
|
||||
|
||||
/*
|
||||
* Warn about missing commits in the submodule project, but only if
|
||||
|
|
28
tag.c
28
tag.c
|
@ -64,11 +64,11 @@ int gpg_verify_tag(const struct object_id *oid, const char *name_to_report,
|
|||
return ret;
|
||||
}
|
||||
|
||||
struct object *deref_tag(struct object *o, const char *warn, int warnlen)
|
||||
struct object *deref_tag(struct repository *r, struct object *o, const char *warn, int warnlen)
|
||||
{
|
||||
while (o && o->type == OBJ_TAG)
|
||||
if (((struct tag *)o)->tagged)
|
||||
o = parse_object(&((struct tag *)o)->tagged->oid);
|
||||
o = parse_object(r, &((struct tag *)o)->tagged->oid);
|
||||
else
|
||||
o = NULL;
|
||||
if (!o && warn) {
|
||||
|
@ -82,7 +82,7 @@ struct object *deref_tag(struct object *o, const char *warn, int warnlen)
|
|||
struct object *deref_tag_noverify(struct object *o)
|
||||
{
|
||||
while (o && o->type == OBJ_TAG) {
|
||||
o = parse_object(&o->oid);
|
||||
o = parse_object(the_repository, &o->oid);
|
||||
if (o && o->type == OBJ_TAG && ((struct tag *)o)->tagged)
|
||||
o = ((struct tag *)o)->tagged;
|
||||
else
|
||||
|
@ -91,13 +91,13 @@ struct object *deref_tag_noverify(struct object *o)
|
|||
return o;
|
||||
}
|
||||
|
||||
struct tag *lookup_tag(const struct object_id *oid)
|
||||
struct tag *lookup_tag(struct repository *r, const struct object_id *oid)
|
||||
{
|
||||
struct object *obj = lookup_object(oid->hash);
|
||||
struct object *obj = lookup_object(r, oid->hash);
|
||||
if (!obj)
|
||||
return create_object(the_repository, oid->hash,
|
||||
alloc_tag_node(the_repository));
|
||||
return object_as_type(obj, OBJ_TAG, 0);
|
||||
return create_object(r, oid->hash,
|
||||
alloc_tag_node(r));
|
||||
return object_as_type(r, obj, OBJ_TAG, 0);
|
||||
}
|
||||
|
||||
static timestamp_t parse_tag_date(const char *buf, const char *tail)
|
||||
|
@ -125,7 +125,7 @@ void release_tag_memory(struct tag *t)
|
|||
t->date = 0;
|
||||
}
|
||||
|
||||
int parse_tag_buffer(struct tag *item, const void *data, unsigned long size)
|
||||
int parse_tag_buffer(struct repository *r, struct tag *item, const void *data, unsigned long size)
|
||||
{
|
||||
struct object_id oid;
|
||||
char type[20];
|
||||
|
@ -153,13 +153,13 @@ int parse_tag_buffer(struct tag *item, const void *data, unsigned long size)
|
|||
bufptr = nl + 1;
|
||||
|
||||
if (!strcmp(type, blob_type)) {
|
||||
item->tagged = (struct object *)lookup_blob(&oid);
|
||||
item->tagged = (struct object *)lookup_blob(r, &oid);
|
||||
} else if (!strcmp(type, tree_type)) {
|
||||
item->tagged = (struct object *)lookup_tree(&oid);
|
||||
item->tagged = (struct object *)lookup_tree(r, &oid);
|
||||
} else if (!strcmp(type, commit_type)) {
|
||||
item->tagged = (struct object *)lookup_commit(&oid);
|
||||
item->tagged = (struct object *)lookup_commit(r, &oid);
|
||||
} else if (!strcmp(type, tag_type)) {
|
||||
item->tagged = (struct object *)lookup_tag(&oid);
|
||||
item->tagged = (struct object *)lookup_tag(r, &oid);
|
||||
} else {
|
||||
error("Unknown type %s", type);
|
||||
item->tagged = NULL;
|
||||
|
@ -202,7 +202,7 @@ int parse_tag(struct tag *item)
|
|||
return error("Object %s not a tag",
|
||||
oid_to_hex(&item->object.oid));
|
||||
}
|
||||
ret = parse_tag_buffer(item, data, size);
|
||||
ret = parse_tag_buffer(the_repository, item, data, size);
|
||||
free(data);
|
||||
return ret;
|
||||
}
|
||||
|
|
7
tag.h
7
tag.h
|
@ -11,12 +11,11 @@ struct tag {
|
|||
char *tag;
|
||||
timestamp_t date;
|
||||
};
|
||||
|
||||
extern struct tag *lookup_tag(const struct object_id *oid);
|
||||
extern int parse_tag_buffer(struct tag *item, const void *data, unsigned long size);
|
||||
extern struct tag *lookup_tag(struct repository *r, const struct object_id *oid);
|
||||
extern int parse_tag_buffer(struct repository *r, struct tag *item, const void *data, unsigned long size);
|
||||
extern int parse_tag(struct tag *item);
|
||||
extern void release_tag_memory(struct tag *t);
|
||||
extern struct object *deref_tag(struct object *, const char *, int);
|
||||
extern struct object *deref_tag(struct repository *r, struct object *, const char *, int);
|
||||
extern struct object *deref_tag_noverify(struct object *);
|
||||
extern int gpg_verify_tag(const struct object_id *oid,
|
||||
const char *name_to_report, unsigned flags);
|
||||
|
|
19
tree.c
19
tree.c
|
@ -8,6 +8,7 @@
|
|||
#include "tag.h"
|
||||
#include "alloc.h"
|
||||
#include "tree-walk.h"
|
||||
#include "repository.h"
|
||||
|
||||
const char *tree_type = "tree";
|
||||
|
||||
|
@ -100,7 +101,7 @@ static int read_tree_1(struct tree *tree, struct strbuf *base,
|
|||
else if (S_ISGITLINK(entry.mode)) {
|
||||
struct commit *commit;
|
||||
|
||||
commit = lookup_commit(entry.oid);
|
||||
commit = lookup_commit(the_repository, entry.oid);
|
||||
if (!commit)
|
||||
die("Commit %s in submodule path %s%s not found",
|
||||
oid_to_hex(entry.oid),
|
||||
|
@ -119,7 +120,7 @@ static int read_tree_1(struct tree *tree, struct strbuf *base,
|
|||
len = tree_entry_len(&entry);
|
||||
strbuf_add(base, entry.path, len);
|
||||
strbuf_addch(base, '/');
|
||||
retval = read_tree_1(lookup_tree(&oid),
|
||||
retval = read_tree_1(lookup_tree(the_repository, &oid),
|
||||
base, stage, pathspec,
|
||||
fn, context);
|
||||
strbuf_setlen(base, oldlen);
|
||||
|
@ -194,13 +195,13 @@ int read_tree(struct tree *tree, int stage, struct pathspec *match,
|
|||
return 0;
|
||||
}
|
||||
|
||||
struct tree *lookup_tree(const struct object_id *oid)
|
||||
struct tree *lookup_tree(struct repository *r, const struct object_id *oid)
|
||||
{
|
||||
struct object *obj = lookup_object(oid->hash);
|
||||
struct object *obj = lookup_object(r, oid->hash);
|
||||
if (!obj)
|
||||
return create_object(the_repository, oid->hash,
|
||||
alloc_tree_node(the_repository));
|
||||
return object_as_type(obj, OBJ_TREE, 0);
|
||||
return create_object(r, oid->hash,
|
||||
alloc_tree_node(r));
|
||||
return object_as_type(r, obj, OBJ_TREE, 0);
|
||||
}
|
||||
|
||||
int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
|
||||
|
@ -244,7 +245,7 @@ void free_tree_buffer(struct tree *tree)
|
|||
|
||||
struct tree *parse_tree_indirect(const struct object_id *oid)
|
||||
{
|
||||
struct object *obj = parse_object(oid);
|
||||
struct object *obj = parse_object(the_repository, oid);
|
||||
do {
|
||||
if (!obj)
|
||||
return NULL;
|
||||
|
@ -257,6 +258,6 @@ struct tree *parse_tree_indirect(const struct object_id *oid)
|
|||
else
|
||||
return NULL;
|
||||
if (!obj->parsed)
|
||||
parse_object(&obj->oid);
|
||||
parse_object(the_repository, &obj->oid);
|
||||
} while (1);
|
||||
}
|
||||
|
|
2
tree.h
2
tree.h
|
@ -12,7 +12,7 @@ struct tree {
|
|||
unsigned long size;
|
||||
};
|
||||
|
||||
struct tree *lookup_tree(const struct object_id *oid);
|
||||
struct tree *lookup_tree(struct repository *r, const struct object_id *oid);
|
||||
|
||||
int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size);
|
||||
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
#include "refs.h"
|
||||
#include "pkt-line.h"
|
||||
#include "sideband.h"
|
||||
#include "repository.h"
|
||||
#include "object-store.h"
|
||||
#include "tag.h"
|
||||
#include "object.h"
|
||||
|
@ -312,7 +313,7 @@ static int got_oid(const char *hex, struct object_id *oid)
|
|||
if (!has_object_file(oid))
|
||||
return -1;
|
||||
|
||||
o = parse_object(oid);
|
||||
o = parse_object(the_repository, oid);
|
||||
if (!o)
|
||||
die("oops (%s)", oid_to_hex(oid));
|
||||
if (o->type == OBJ_COMMIT) {
|
||||
|
@ -350,7 +351,7 @@ static int reachable(struct commit *want)
|
|||
break;
|
||||
}
|
||||
if (!commit->object.parsed)
|
||||
parse_object(&commit->object.oid);
|
||||
parse_object(the_repository, &commit->object.oid);
|
||||
if (commit->object.flags & REACHABLE)
|
||||
continue;
|
||||
commit->object.flags |= REACHABLE;
|
||||
|
@ -380,7 +381,7 @@ static int ok_to_give_up(void)
|
|||
|
||||
if (want->flags & COMMON_KNOWN)
|
||||
continue;
|
||||
want = deref_tag(want, "a want line", 0);
|
||||
want = deref_tag(the_repository, want, "a want line", 0);
|
||||
if (!want || want->type != OBJ_COMMIT) {
|
||||
/* no way to tell if this is reachable by
|
||||
* looking at the ancestry chain alone, so
|
||||
|
@ -570,7 +571,7 @@ static int get_reachable_list(struct object_array *src,
|
|||
if (parse_oid_hex(namebuf, &sha1, &p) || *p != '\n')
|
||||
break;
|
||||
|
||||
o = lookup_object(sha1.hash);
|
||||
o = lookup_object(the_repository, sha1.hash);
|
||||
if (o && o->type == OBJ_COMMIT) {
|
||||
o->flags &= ~TMP_MARK;
|
||||
}
|
||||
|
@ -801,7 +802,7 @@ static int process_shallow(const char *line, struct object_array *shallows)
|
|||
struct object *object;
|
||||
if (get_oid_hex(arg, &oid))
|
||||
die("invalid shallow line: %s", line);
|
||||
object = parse_object(&oid);
|
||||
object = parse_object(the_repository, &oid);
|
||||
if (!object)
|
||||
return 1;
|
||||
if (object->type != OBJ_COMMIT)
|
||||
|
@ -927,7 +928,7 @@ static void receive_needs(void)
|
|||
if (allow_filter && parse_feature_request(features, "filter"))
|
||||
filter_capability_requested = 1;
|
||||
|
||||
o = parse_object(&oid_buf);
|
||||
o = parse_object(the_repository, &oid_buf);
|
||||
if (!o) {
|
||||
packet_write_fmt(1,
|
||||
"ERR upload-pack: not our ref %s",
|
||||
|
@ -1174,7 +1175,7 @@ static int parse_want(const char *line)
|
|||
die("git upload-pack: protocol error, "
|
||||
"expected to get oid, not '%s'", line);
|
||||
|
||||
o = parse_object(&oid);
|
||||
o = parse_object(the_repository, &oid);
|
||||
if (!o) {
|
||||
packet_write_fmt(1,
|
||||
"ERR upload-pack: not our ref %s",
|
||||
|
@ -1316,7 +1317,7 @@ static int process_haves(struct oid_array *haves, struct oid_array *common)
|
|||
|
||||
oid_array_append(common, oid);
|
||||
|
||||
o = parse_object(oid);
|
||||
o = parse_object(the_repository, oid);
|
||||
if (!o)
|
||||
die("oops (%s)", oid_to_hex(oid));
|
||||
if (o->type == OBJ_COMMIT) {
|
||||
|
|
12
walker.c
12
walker.c
|
@ -1,5 +1,6 @@
|
|||
#include "cache.h"
|
||||
#include "walker.h"
|
||||
#include "repository.h"
|
||||
#include "object-store.h"
|
||||
#include "commit.h"
|
||||
#include "tree.h"
|
||||
|
@ -48,12 +49,14 @@ static int process_tree(struct walker *walker, struct tree *tree)
|
|||
if (S_ISGITLINK(entry.mode))
|
||||
continue;
|
||||
if (S_ISDIR(entry.mode)) {
|
||||
struct tree *tree = lookup_tree(entry.oid);
|
||||
struct tree *tree = lookup_tree(the_repository,
|
||||
entry.oid);
|
||||
if (tree)
|
||||
obj = &tree->object;
|
||||
}
|
||||
else {
|
||||
struct blob *blob = lookup_blob(entry.oid);
|
||||
struct blob *blob = lookup_blob(the_repository,
|
||||
entry.oid);
|
||||
if (blob)
|
||||
obj = &blob->object;
|
||||
}
|
||||
|
@ -178,7 +181,7 @@ static int loop(struct walker *walker)
|
|||
}
|
||||
}
|
||||
if (!obj->type)
|
||||
parse_object(&obj->oid);
|
||||
parse_object(the_repository, &obj->oid);
|
||||
if (process_object(walker, obj))
|
||||
return -1;
|
||||
}
|
||||
|
@ -204,7 +207,8 @@ static int interpret_target(struct walker *walker, char *target, struct object_i
|
|||
static int mark_complete(const char *path, const struct object_id *oid,
|
||||
int flag, void *cb_data)
|
||||
{
|
||||
struct commit *commit = lookup_commit_reference_gently(oid, 1);
|
||||
struct commit *commit = lookup_commit_reference_gently(the_repository,
|
||||
oid, 1);
|
||||
|
||||
if (commit) {
|
||||
commit->object.flags |= COMPLETE;
|
||||
|
|
|
@ -1489,7 +1489,7 @@ static void wt_status_get_detached_from(struct wt_status_state *state)
|
|||
/* sha1 is a commit? match without further lookup */
|
||||
(!oidcmp(&cb.noid, &oid) ||
|
||||
/* perhaps sha1 is a tag, try to dereference to a commit */
|
||||
((commit = lookup_commit_reference_gently(&oid, 1)) != NULL &&
|
||||
((commit = lookup_commit_reference_gently(the_repository, &oid, 1)) != NULL &&
|
||||
!oidcmp(&cb.noid, &commit->object.oid)))) {
|
||||
const char *from = ref;
|
||||
if (!skip_prefix(from, "refs/tags/", &from))
|
||||
|
@ -2347,7 +2347,7 @@ int has_uncommitted_changes(int ignore_submodules)
|
|||
* We have no head (or it's corrupt); use the empty tree,
|
||||
* which will complain if the index is non-empty.
|
||||
*/
|
||||
struct tree *tree = lookup_tree(the_hash_algo->empty_tree);
|
||||
struct tree *tree = lookup_tree(the_repository, the_hash_algo->empty_tree);
|
||||
add_pending_object(&rev_info, &tree->object, "");
|
||||
}
|
||||
|
||||
|
|
Загрузка…
Ссылка в новой задаче