mirror of
https://github.com/git/git.git
synced 2024-05-09 10:16:08 +02:00
Merge branch 'nd/sha1-name-c-wo-the-repository'
Further code clean-up to allow the lowest level of name-to-object mapping layer to work with a passed-in repository other than the default one. * nd/sha1-name-c-wo-the-repository: (34 commits) sha1-name.c: remove the_repo from get_oid_mb() sha1-name.c: remove the_repo from other get_oid_* sha1-name.c: remove the_repo from maybe_die_on_misspelt_object_name submodule-config.c: use repo_get_oid for reading .gitmodules sha1-name.c: add repo_get_oid() sha1-name.c: remove the_repo from get_oid_with_context_1() sha1-name.c: remove the_repo from resolve_relative_path() sha1-name.c: remove the_repo from diagnose_invalid_index_path() sha1-name.c: remove the_repo from handle_one_ref() sha1-name.c: remove the_repo from get_oid_1() sha1-name.c: remove the_repo from get_oid_basic() sha1-name.c: remove the_repo from get_describe_name() sha1-name.c: remove the_repo from get_oid_oneline() sha1-name.c: add repo_interpret_branch_name() sha1-name.c: remove the_repo from interpret_branch_mark() sha1-name.c: remove the_repo from interpret_nth_prior_checkout() sha1-name.c: remove the_repo from get_short_oid() sha1-name.c: add repo_for_each_abbrev() sha1-name.c: store and use repo in struct disambiguate_state sha1-name.c: add repo_find_unique_abbrev_r() ...
This commit is contained in:
Junio C Hamano
commit
0b179f3175
|
|
@ -1568,8 +1568,7 @@ int cmd_rebase(int argc, const char **argv, const char *prefix)
|
|||
branch_name = options.head_name;
|
||||
|
||||
} else {
|
||||
free(options.head_name);
|
||||
options.head_name = NULL;
|
||||
FREE_AND_NULL(options.head_name);
|
||||
branch_name = "HEAD";
|
||||
}
|
||||
if (get_oid("HEAD", &options.orig_head))
|
||||
|
|
@ -1769,7 +1768,7 @@ int cmd_rebase(int argc, const char **argv, const char *prefix)
|
|||
* we just fast-forwarded.
|
||||
*/
|
||||
strbuf_reset(&msg);
|
||||
if (!oidcmp(&merge_base, &options.orig_head)) {
|
||||
if (oideq(&merge_base, &options.orig_head)) {
|
||||
printf(_("Fast-forwarded %s to %s.\n"),
|
||||
branch_name, options.onto_name);
|
||||
strbuf_addf(&msg, "rebase finished: %s onto %s",
|
||||
|
|
|
|||
|
|
@ -753,7 +753,8 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
/* Ah, that is a date spec... */
|
||||
timestamp_t at;
|
||||
at = approxidate(reflog_base);
|
||||
read_ref_at(ref, flags, at, -1, &oid, NULL,
|
||||
read_ref_at(get_main_ref_store(the_repository),
|
||||
ref, flags, at, -1, &oid, NULL,
|
||||
NULL, NULL, &base);
|
||||
}
|
||||
}
|
||||
|
|
@ -765,7 +766,8 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
|
|||
timestamp_t timestamp;
|
||||
int tz;
|
||||
|
||||
if (read_ref_at(ref, flags, 0, base + i, &oid, &logmsg,
|
||||
if (read_ref_at(get_main_ref_store(the_repository),
|
||||
ref, flags, 0, base + i, &oid, &logmsg,
|
||||
×tamp, &tz, NULL)) {
|
||||
reflog = i;
|
||||
break;
|
||||
|
|
|
|||
52
cache.h
52
cache.h
|
|
@ -1047,8 +1047,10 @@ extern void check_repository_format(void);
|
|||
* Note that while this version avoids the static buffer, it is not fully
|
||||
* reentrant, as it calls into other non-reentrant git code.
|
||||
*/
|
||||
extern const char *find_unique_abbrev(const struct object_id *oid, int len);
|
||||
extern int find_unique_abbrev_r(char *hex, const struct object_id *oid, int len);
|
||||
const char *repo_find_unique_abbrev(struct repository *r, const struct object_id *oid, int len);
|
||||
#define find_unique_abbrev(oid, len) repo_find_unique_abbrev(the_repository, oid, len)
|
||||
int repo_find_unique_abbrev_r(struct repository *r, char *hex, const struct object_id *oid, int len);
|
||||
#define find_unique_abbrev_r(hex, oid, len) repo_find_unique_abbrev_r(the_repository, hex, oid, len)
|
||||
|
||||
extern const unsigned char null_sha1[GIT_MAX_RAWSZ];
|
||||
extern const struct object_id null_oid;
|
||||
|
|
@ -1380,20 +1382,32 @@ enum get_oid_result {
|
|||
*/
|
||||
};
|
||||
|
||||
extern int get_oid(const char *str, struct object_id *oid);
|
||||
extern int get_oidf(struct object_id *oid, const char *fmt, ...);
|
||||
extern int get_oid_commit(const char *str, struct object_id *oid);
|
||||
extern int get_oid_committish(const char *str, struct object_id *oid);
|
||||
extern int get_oid_tree(const char *str, struct object_id *oid);
|
||||
extern int get_oid_treeish(const char *str, struct object_id *oid);
|
||||
extern int get_oid_blob(const char *str, struct object_id *oid);
|
||||
extern void maybe_die_on_misspelt_object_name(const char *name, const char *prefix);
|
||||
int repo_get_oid(struct repository *r, const char *str, struct object_id *oid);
|
||||
int get_oidf(struct object_id *oid, const char *fmt, ...);
|
||||
int repo_get_oid_commit(struct repository *r, const char *str, struct object_id *oid);
|
||||
int repo_get_oid_committish(struct repository *r, const char *str, struct object_id *oid);
|
||||
int repo_get_oid_tree(struct repository *r, const char *str, struct object_id *oid);
|
||||
int repo_get_oid_treeish(struct repository *r, const char *str, struct object_id *oid);
|
||||
int repo_get_oid_blob(struct repository *r, const char *str, struct object_id *oid);
|
||||
int repo_get_oid_mb(struct repository *r, const char *str, struct object_id *oid);
|
||||
void maybe_die_on_misspelt_object_name(struct repository *repo,
|
||||
const char *name,
|
||||
const char *prefix);
|
||||
extern enum get_oid_result get_oid_with_context(struct repository *repo, const char *str,
|
||||
unsigned flags, struct object_id *oid,
|
||||
struct object_context *oc);
|
||||
|
||||
#define get_oid(str, oid) repo_get_oid(the_repository, str, oid)
|
||||
#define get_oid_commit(str, oid) repo_get_oid_commit(the_repository, str, oid)
|
||||
#define get_oid_committish(str, oid) repo_get_oid_committish(the_repository, str, oid)
|
||||
#define get_oid_tree(str, oid) repo_get_oid_tree(the_repository, str, oid)
|
||||
#define get_oid_treeish(str, oid) repo_get_oid_treeish(the_repository, str, oid)
|
||||
#define get_oid_blob(str, oid) repo_get_oid_blob(the_repository, str, oid)
|
||||
#define get_oid_mb(str, oid) repo_get_oid_mb(the_repository, str, oid)
|
||||
|
||||
typedef int each_abbrev_fn(const struct object_id *oid, void *);
|
||||
extern int for_each_abbrev(const char *prefix, each_abbrev_fn, void *);
|
||||
int repo_for_each_abbrev(struct repository *r, const char *prefix, each_abbrev_fn, void *);
|
||||
#define for_each_abbrev(prefix, fn, data) repo_for_each_abbrev(the_repository, prefix, fn, data)
|
||||
|
||||
extern int set_disambiguate_hint_config(const char *var, const char *value);
|
||||
|
||||
|
|
@ -1471,9 +1485,12 @@ extern int parse_oid_hex(const char *hex, struct object_id *oid, const char **en
|
|||
#define INTERPRET_BRANCH_LOCAL (1<<0)
|
||||
#define INTERPRET_BRANCH_REMOTE (1<<1)
|
||||
#define INTERPRET_BRANCH_HEAD (1<<2)
|
||||
extern int interpret_branch_name(const char *str, int len, struct strbuf *,
|
||||
unsigned allowed);
|
||||
extern int get_oid_mb(const char *str, struct object_id *oid);
|
||||
int repo_interpret_branch_name(struct repository *r,
|
||||
const char *str, int len,
|
||||
struct strbuf *buf,
|
||||
unsigned allowed);
|
||||
#define interpret_branch_name(str, len, buf, allowed) \
|
||||
repo_interpret_branch_name(the_repository, str, len, buf, allowed)
|
||||
|
||||
extern int validate_headref(const char *ref);
|
||||
|
||||
|
|
@ -1487,8 +1504,11 @@ extern void *read_object_with_reference(const struct object_id *oid,
|
|||
unsigned long *size,
|
||||
struct object_id *oid_ret);
|
||||
|
||||
extern struct object *peel_to_type(const char *name, int namelen,
|
||||
struct object *o, enum object_type);
|
||||
struct object *repo_peel_to_type(struct repository *r,
|
||||
const char *name, int namelen,
|
||||
struct object *o, enum object_type);
|
||||
#define peel_to_type(name, namelen, obj, type) \
|
||||
repo_peel_to_type(the_repository, name, namelen, obj, type)
|
||||
|
||||
enum date_mode_type {
|
||||
DATE_NORMAL = 0,
|
||||
|
|
|
|||
|
|
@ -397,6 +397,11 @@ static void fill_commit_graph_info(struct commit *item, struct commit_graph *g,
|
|||
item->generation = get_be32(commit_data + g->hash_len + 8) >> 2;
|
||||
}
|
||||
|
||||
static inline void set_commit_tree(struct commit *c, struct tree *t)
|
||||
{
|
||||
c->maybe_tree = t;
|
||||
}
|
||||
|
||||
static int fill_commit_in_graph(struct repository *r,
|
||||
struct commit *item,
|
||||
struct commit_graph *g, uint32_t pos)
|
||||
|
|
@ -410,7 +415,7 @@ static int fill_commit_in_graph(struct repository *r,
|
|||
item->object.parsed = 1;
|
||||
item->graph_pos = pos;
|
||||
|
||||
item->maybe_tree = NULL;
|
||||
set_commit_tree(item, NULL);
|
||||
|
||||
date_high = get_be32(commit_data + g->hash_len + 8) & 0x3;
|
||||
date_low = get_be32(commit_data + g->hash_len + 12);
|
||||
|
|
@ -496,7 +501,7 @@ static struct tree *load_tree_for_commit(struct repository *r,
|
|||
GRAPH_DATA_WIDTH * (c->graph_pos);
|
||||
|
||||
hashcpy(oid.hash, commit_data);
|
||||
c->maybe_tree = lookup_tree(r, &oid);
|
||||
set_commit_tree(c, lookup_tree(r, &oid));
|
||||
|
||||
return c->maybe_tree;
|
||||
}
|
||||
|
|
|
|||
14
commit.c
14
commit.c
|
|
@ -340,7 +340,13 @@ void free_commit_buffer(struct parsed_object_pool *pool, struct commit *commit)
|
|||
}
|
||||
}
|
||||
|
||||
struct tree *get_commit_tree(const struct commit *commit)
|
||||
static inline void set_commit_tree(struct commit *c, struct tree *t)
|
||||
{
|
||||
c->maybe_tree = t;
|
||||
}
|
||||
|
||||
struct tree *repo_get_commit_tree(struct repository *r,
|
||||
const struct commit *commit)
|
||||
{
|
||||
if (commit->maybe_tree || !commit->object.parsed)
|
||||
return commit->maybe_tree;
|
||||
|
|
@ -348,7 +354,7 @@ struct tree *get_commit_tree(const struct commit *commit)
|
|||
if (commit->graph_pos == COMMIT_NOT_FROM_GRAPH)
|
||||
BUG("commit has NULL tree, but was not loaded from commit-graph");
|
||||
|
||||
return get_commit_tree_in_graph(the_repository, commit);
|
||||
return get_commit_tree_in_graph(r, commit);
|
||||
}
|
||||
|
||||
struct object_id *get_commit_tree_oid(const struct commit *commit)
|
||||
|
|
@ -358,7 +364,7 @@ struct object_id *get_commit_tree_oid(const struct commit *commit)
|
|||
|
||||
void release_commit_memory(struct parsed_object_pool *pool, struct commit *c)
|
||||
{
|
||||
c->maybe_tree = NULL;
|
||||
set_commit_tree(c, NULL);
|
||||
c->index = 0;
|
||||
free_commit_buffer(pool, c);
|
||||
free_commit_list(c->parents);
|
||||
|
|
@ -406,7 +412,7 @@ int parse_commit_buffer(struct repository *r, struct commit *item, const void *b
|
|||
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(r, &parent);
|
||||
set_commit_tree(item, lookup_tree(r, &parent));
|
||||
bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
|
||||
pptr = &item->parents;
|
||||
|
||||
|
|
|
|||
5
commit.h
5
commit.h
|
|
@ -32,7 +32,7 @@ struct commit {
|
|||
|
||||
/*
|
||||
* If the commit is loaded from the commit-graph file, then this
|
||||
* member may be NULL. Only access it through get_commit_tree()
|
||||
* member may be NULL. Only access it through repo_get_commit_tree()
|
||||
* or get_commit_tree_oid().
|
||||
*/
|
||||
struct tree *maybe_tree;
|
||||
|
|
@ -149,7 +149,8 @@ void repo_unuse_commit_buffer(struct repository *r,
|
|||
*/
|
||||
void free_commit_buffer(struct parsed_object_pool *pool, struct commit *);
|
||||
|
||||
struct tree *get_commit_tree(const struct commit *);
|
||||
struct tree *repo_get_commit_tree(struct repository *, const struct commit *);
|
||||
#define get_commit_tree(c) repo_get_commit_tree(the_repository, c)
|
||||
struct object_id *get_commit_tree_oid(const struct commit *);
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -10,19 +10,25 @@ expression c;
|
|||
- c->maybe_tree->object.oid.hash
|
||||
+ get_commit_tree_oid(c)->hash
|
||||
|
||||
// These excluded functions must access c->maybe_tree direcly.
|
||||
@@
|
||||
identifier f !~ "^(get_commit_tree|get_commit_tree_in_graph_one|load_tree_for_commit)$";
|
||||
identifier f !~ "^set_commit_tree$";
|
||||
expression c;
|
||||
expression s;
|
||||
@@
|
||||
f(...) {<...
|
||||
- c->maybe_tree = s
|
||||
+ set_commit_tree(c, s)
|
||||
...>}
|
||||
|
||||
// These excluded functions must access c->maybe_tree direcly.
|
||||
// Note that if c->maybe_tree is written somewhere outside of these
|
||||
// functions, then the recommended transformation will be bogus with
|
||||
// repo_get_commit_tree() on the LHS.
|
||||
@@
|
||||
identifier f !~ "^(repo_get_commit_tree|get_commit_tree_in_graph_one|load_tree_for_commit|set_commit_tree)$";
|
||||
expression c;
|
||||
@@
|
||||
f(...) {<...
|
||||
- c->maybe_tree
|
||||
+ get_commit_tree(c)
|
||||
+ repo_get_commit_tree(specify_the_right_repo_here, c)
|
||||
...>}
|
||||
|
||||
@@
|
||||
expression c;
|
||||
expression s;
|
||||
@@
|
||||
- get_commit_tree(c) = s
|
||||
+ c->maybe_tree = s
|
||||
|
|
|
|||
8
dir.c
8
dir.c
|
|
@ -2316,6 +2316,14 @@ int file_exists(const char *f)
|
|||
return lstat(f, &sb) == 0;
|
||||
}
|
||||
|
||||
int repo_file_exists(struct repository *repo, const char *path)
|
||||
{
|
||||
if (repo != the_repository)
|
||||
BUG("do not know how to check file existence in arbitrary repo");
|
||||
|
||||
return file_exists(path);
|
||||
}
|
||||
|
||||
static int cmp_icase(char a, char b)
|
||||
{
|
||||
if (a == b)
|
||||
|
|
|
|||
4
dir.h
4
dir.h
|
|
@ -269,7 +269,9 @@ extern void add_exclude(const char *string, const char *base,
|
|||
int baselen, struct exclude_list *el, int srcpos);
|
||||
extern void clear_exclude_list(struct exclude_list *el);
|
||||
extern void clear_directory(struct dir_struct *dir);
|
||||
extern int file_exists(const char *);
|
||||
|
||||
int repo_file_exists(struct repository *repo, const char *path);
|
||||
int file_exists(const char *);
|
||||
|
||||
extern int is_inside_dir(const char *dir);
|
||||
extern int dir_inside_of(const char *subdir, const char *dir);
|
||||
|
|
|
|||
|
|
@ -163,6 +163,11 @@ static struct tree *shift_tree_object(struct repository *repo,
|
|||
return lookup_tree(repo, &shifted);
|
||||
}
|
||||
|
||||
static inline void set_commit_tree(struct commit *c, struct tree *t)
|
||||
{
|
||||
c->maybe_tree = t;
|
||||
}
|
||||
|
||||
static struct commit *make_virtual_commit(struct repository *repo,
|
||||
struct tree *tree,
|
||||
const char *comment)
|
||||
|
|
@ -170,7 +175,7 @@ static struct commit *make_virtual_commit(struct repository *repo,
|
|||
struct commit *commit = alloc_commit_node(repo);
|
||||
|
||||
set_merge_remote_desc(commit, comment, (struct object *)commit);
|
||||
commit->maybe_tree = tree;
|
||||
set_commit_tree(commit, tree);
|
||||
commit->object.parsed = 1;
|
||||
return commit;
|
||||
}
|
||||
|
|
|
|||
14
packfile.c
14
packfile.c
|
|
@ -903,25 +903,25 @@ static void prepare_packed_git(struct repository *r);
|
|||
* all unreachable objects about to be pruned, in which case they're not really
|
||||
* interesting as a measure of repo size in the first place.
|
||||
*/
|
||||
unsigned long approximate_object_count(void)
|
||||
unsigned long repo_approximate_object_count(struct repository *r)
|
||||
{
|
||||
if (!the_repository->objects->approximate_object_count_valid) {
|
||||
if (!r->objects->approximate_object_count_valid) {
|
||||
unsigned long count;
|
||||
struct multi_pack_index *m;
|
||||
struct packed_git *p;
|
||||
|
||||
prepare_packed_git(the_repository);
|
||||
prepare_packed_git(r);
|
||||
count = 0;
|
||||
for (m = get_multi_pack_index(the_repository); m; m = m->next)
|
||||
for (m = get_multi_pack_index(r); m; m = m->next)
|
||||
count += m->num_objects;
|
||||
for (p = the_repository->objects->packed_git; p; p = p->next) {
|
||||
for (p = r->objects->packed_git; p; p = p->next) {
|
||||
if (open_pack_index(p))
|
||||
continue;
|
||||
count += p->num_objects;
|
||||
}
|
||||
the_repository->objects->approximate_object_count = count;
|
||||
r->objects->approximate_object_count = count;
|
||||
}
|
||||
return the_repository->objects->approximate_object_count;
|
||||
return r->objects->approximate_object_count;
|
||||
}
|
||||
|
||||
static void *get_next_packed_git(const void *p)
|
||||
|
|
|
|||
|
|
@ -63,7 +63,8 @@ struct packed_git *get_all_packs(struct repository *r);
|
|||
* Give a rough count of objects in the repository. This sacrifices accuracy
|
||||
* for speed.
|
||||
*/
|
||||
unsigned long approximate_object_count(void);
|
||||
unsigned long repo_approximate_object_count(struct repository *r);
|
||||
#define approximate_object_count() repo_approximate_object_count(the_repository)
|
||||
|
||||
struct packed_git *find_sha1_pack(const unsigned char *sha1,
|
||||
struct packed_git *packs);
|
||||
|
|
|
|||
71
refs.c
71
refs.c
|
|
@ -241,9 +241,14 @@ int read_ref(const char *refname, struct object_id *oid)
|
|||
return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
|
||||
}
|
||||
|
||||
static int refs_ref_exists(struct ref_store *refs, const char *refname)
|
||||
{
|
||||
return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING, NULL, NULL);
|
||||
}
|
||||
|
||||
int ref_exists(const char *refname)
|
||||
{
|
||||
return !!resolve_ref_unsafe(refname, RESOLVE_REF_READING, NULL, NULL);
|
||||
return refs_ref_exists(get_main_ref_store(the_repository), refname);
|
||||
}
|
||||
|
||||
static int match_ref_pattern(const char *refname,
|
||||
|
|
@ -534,10 +539,11 @@ void expand_ref_prefix(struct argv_array *prefixes, const char *prefix)
|
|||
* later free()ing) if the string passed in is a magic short-hand form
|
||||
* to name a branch.
|
||||
*/
|
||||
static char *substitute_branch_name(const char **string, int *len)
|
||||
static char *substitute_branch_name(struct repository *r,
|
||||
const char **string, int *len)
|
||||
{
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
int ret = interpret_branch_name(*string, *len, &buf, 0);
|
||||
int ret = repo_interpret_branch_name(r, *string, *len, &buf, 0);
|
||||
|
||||
if (ret == *len) {
|
||||
size_t size;
|
||||
|
|
@ -549,15 +555,22 @@ static char *substitute_branch_name(const char **string, int *len)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
int dwim_ref(const char *str, int len, struct object_id *oid, char **ref)
|
||||
int repo_dwim_ref(struct repository *r, const char *str, int len,
|
||||
struct object_id *oid, char **ref)
|
||||
{
|
||||
char *last_branch = substitute_branch_name(&str, &len);
|
||||
int refs_found = expand_ref(str, len, oid, ref);
|
||||
char *last_branch = substitute_branch_name(r, &str, &len);
|
||||
int refs_found = expand_ref(r, str, len, oid, ref);
|
||||
free(last_branch);
|
||||
return refs_found;
|
||||
}
|
||||
|
||||
int expand_ref(const char *str, int len, struct object_id *oid, char **ref)
|
||||
int dwim_ref(const char *str, int len, struct object_id *oid, char **ref)
|
||||
{
|
||||
return repo_dwim_ref(the_repository, str, len, oid, ref);
|
||||
}
|
||||
|
||||
int expand_ref(struct repository *repo, const char *str, int len,
|
||||
struct object_id *oid, char **ref)
|
||||
{
|
||||
const char **p, *r;
|
||||
int refs_found = 0;
|
||||
|
|
@ -572,8 +585,9 @@ int expand_ref(const char *str, int len, struct object_id *oid, char **ref)
|
|||
this_result = refs_found ? &oid_from_ref : oid;
|
||||
strbuf_reset(&fullref);
|
||||
strbuf_addf(&fullref, *p, len, str);
|
||||
r = resolve_ref_unsafe(fullref.buf, RESOLVE_REF_READING,
|
||||
this_result, &flag);
|
||||
r = refs_resolve_ref_unsafe(get_main_ref_store(repo),
|
||||
fullref.buf, RESOLVE_REF_READING,
|
||||
this_result, &flag);
|
||||
if (r) {
|
||||
if (!refs_found++)
|
||||
*ref = xstrdup(r);
|
||||
|
|
@ -589,9 +603,11 @@ int expand_ref(const char *str, int len, struct object_id *oid, char **ref)
|
|||
return refs_found;
|
||||
}
|
||||
|
||||
int dwim_log(const char *str, int len, struct object_id *oid, char **log)
|
||||
int repo_dwim_log(struct repository *r, const char *str, int len,
|
||||
struct object_id *oid, char **log)
|
||||
{
|
||||
char *last_branch = substitute_branch_name(&str, &len);
|
||||
struct ref_store *refs = get_main_ref_store(r);
|
||||
char *last_branch = substitute_branch_name(r, &str, &len);
|
||||
const char **p;
|
||||
int logs_found = 0;
|
||||
struct strbuf path = STRBUF_INIT;
|
||||
|
|
@ -603,13 +619,15 @@ int dwim_log(const char *str, int len, struct object_id *oid, char **log)
|
|||
|
||||
strbuf_reset(&path);
|
||||
strbuf_addf(&path, *p, len, str);
|
||||
ref = resolve_ref_unsafe(path.buf, RESOLVE_REF_READING,
|
||||
&hash, NULL);
|
||||
ref = refs_resolve_ref_unsafe(refs, path.buf,
|
||||
RESOLVE_REF_READING,
|
||||
&hash, NULL);
|
||||
if (!ref)
|
||||
continue;
|
||||
if (reflog_exists(path.buf))
|
||||
if (refs_reflog_exists(refs, path.buf))
|
||||
it = path.buf;
|
||||
else if (strcmp(ref, path.buf) && reflog_exists(ref))
|
||||
else if (strcmp(ref, path.buf) &&
|
||||
refs_reflog_exists(refs, ref))
|
||||
it = ref;
|
||||
else
|
||||
continue;
|
||||
|
|
@ -625,6 +643,11 @@ int dwim_log(const char *str, int len, struct object_id *oid, char **log)
|
|||
return logs_found;
|
||||
}
|
||||
|
||||
int dwim_log(const char *str, int len, struct object_id *oid, char **log)
|
||||
{
|
||||
return repo_dwim_log(the_repository, str, len, oid, log);
|
||||
}
|
||||
|
||||
static int is_per_worktree_ref(const char *refname)
|
||||
{
|
||||
return !strcmp(refname, "HEAD") ||
|
||||
|
|
@ -944,7 +967,8 @@ static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid
|
|||
return 1;
|
||||
}
|
||||
|
||||
int read_ref_at(const char *refname, unsigned int flags, timestamp_t at_time, int cnt,
|
||||
int read_ref_at(struct ref_store *refs, const char *refname,
|
||||
unsigned int flags, timestamp_t at_time, int cnt,
|
||||
struct object_id *oid, char **msg,
|
||||
timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
|
||||
{
|
||||
|
|
@ -960,7 +984,7 @@ int read_ref_at(const char *refname, unsigned int flags, timestamp_t at_time, in
|
|||
cb.cutoff_cnt = cutoff_cnt;
|
||||
cb.oid = oid;
|
||||
|
||||
for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);
|
||||
refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
|
||||
|
||||
if (!cb.reccnt) {
|
||||
if (flags & GET_OID_QUIETLY)
|
||||
|
|
@ -971,7 +995,7 @@ int read_ref_at(const char *refname, unsigned int flags, timestamp_t at_time, in
|
|||
if (cb.found_it)
|
||||
return 0;
|
||||
|
||||
for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);
|
||||
refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1164,7 +1188,8 @@ int update_ref(const char *msg, const char *refname,
|
|||
old_oid, flags, onerr);
|
||||
}
|
||||
|
||||
char *shorten_unambiguous_ref(const char *refname, int strict)
|
||||
char *refs_shorten_unambiguous_ref(struct ref_store *refs,
|
||||
const char *refname, int strict)
|
||||
{
|
||||
int i;
|
||||
static char **scanf_fmts;
|
||||
|
|
@ -1242,7 +1267,7 @@ char *shorten_unambiguous_ref(const char *refname, int strict)
|
|||
strbuf_reset(&resolved_buf);
|
||||
strbuf_addf(&resolved_buf, rule,
|
||||
short_name_len, short_name);
|
||||
if (ref_exists(resolved_buf.buf))
|
||||
if (refs_ref_exists(refs, resolved_buf.buf))
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -1261,6 +1286,12 @@ char *shorten_unambiguous_ref(const char *refname, int strict)
|
|||
return xstrdup(refname);
|
||||
}
|
||||
|
||||
char *shorten_unambiguous_ref(const char *refname, int strict)
|
||||
{
|
||||
return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
|
||||
refname, strict);
|
||||
}
|
||||
|
||||
static struct string_list *hide_refs;
|
||||
|
||||
int parse_hide_refs_config(const char *var, const char *value, const char *section)
|
||||
|
|
|
|||
9
refs.h
9
refs.h
|
|
@ -148,7 +148,9 @@ int refname_match(const char *abbrev_name, const char *full_name);
|
|||
struct argv_array;
|
||||
void expand_ref_prefix(struct argv_array *prefixes, const char *prefix);
|
||||
|
||||
int expand_ref(const char *str, int len, struct object_id *oid, char **ref);
|
||||
int expand_ref(struct repository *r, const char *str, int len, struct object_id *oid, char **ref);
|
||||
int repo_dwim_ref(struct repository *r, const char *str, int len, struct object_id *oid, char **ref);
|
||||
int repo_dwim_log(struct repository *r, const char *str, int len, struct object_id *oid, char **ref);
|
||||
int dwim_ref(const char *str, int len, struct object_id *oid, char **ref);
|
||||
int dwim_log(const char *str, int len, struct object_id *oid, char **ref);
|
||||
|
||||
|
|
@ -386,7 +388,8 @@ int refs_create_reflog(struct ref_store *refs, const char *refname,
|
|||
int safe_create_reflog(const char *refname, int force_create, struct strbuf *err);
|
||||
|
||||
/** Reads log for the value of ref during at_time. **/
|
||||
int read_ref_at(const char *refname, unsigned int flags,
|
||||
int read_ref_at(struct ref_store *refs,
|
||||
const char *refname, unsigned int flags,
|
||||
timestamp_t at_time, int cnt,
|
||||
struct object_id *oid, char **msg,
|
||||
timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt);
|
||||
|
|
@ -462,6 +465,8 @@ int check_refname_format(const char *refname, int flags);
|
|||
|
||||
const char *prettify_refname(const char *refname);
|
||||
|
||||
char *refs_shorten_unambiguous_ref(struct ref_store *refs,
|
||||
const char *refname, int strict);
|
||||
char *shorten_unambiguous_ref(const char *refname, int strict);
|
||||
|
||||
/** rename ref, return 0 on success **/
|
||||
|
|
|
|||
7
setup.c
7
setup.c
|
|
@ -164,7 +164,8 @@ int check_filename(const char *prefix, const char *arg)
|
|||
die_errno(_("failed to stat '%s'"), arg);
|
||||
}
|
||||
|
||||
static void NORETURN die_verify_filename(const char *prefix,
|
||||
static void NORETURN die_verify_filename(struct repository *r,
|
||||
const char *prefix,
|
||||
const char *arg,
|
||||
int diagnose_misspelt_rev)
|
||||
{
|
||||
|
|
@ -179,7 +180,7 @@ static void NORETURN die_verify_filename(const char *prefix,
|
|||
* let maybe_die_on_misspelt_object_name() even trigger.
|
||||
*/
|
||||
if (!(arg[0] == ':' && !isalnum(arg[1])))
|
||||
maybe_die_on_misspelt_object_name(arg, prefix);
|
||||
maybe_die_on_misspelt_object_name(r, arg, prefix);
|
||||
|
||||
/* ... or fall back the most general message. */
|
||||
die(_("ambiguous argument '%s': unknown revision or path not in the working tree.\n"
|
||||
|
|
@ -234,7 +235,7 @@ void verify_filename(const char *prefix,
|
|||
die(_("option '%s' must come before non-option arguments"), arg);
|
||||
if (looks_like_pathspec(arg) || check_filename(prefix, arg))
|
||||
return;
|
||||
die_verify_filename(prefix, arg, diagnose_misspelt_rev);
|
||||
die_verify_filename(the_repository, prefix, arg, diagnose_misspelt_rev);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
388
sha1-name.c
388
sha1-name.c
|
|
@ -12,18 +12,20 @@
|
|||
#include "packfile.h"
|
||||
#include "object-store.h"
|
||||
#include "repository.h"
|
||||
#include "submodule.h"
|
||||
#include "midx.h"
|
||||
#include "commit-reach.h"
|
||||
|
||||
static int get_oid_oneline(const char *, struct object_id *, struct commit_list *);
|
||||
static int get_oid_oneline(struct repository *r, const char *, struct object_id *, struct commit_list *);
|
||||
|
||||
typedef int (*disambiguate_hint_fn)(const struct object_id *, void *);
|
||||
typedef int (*disambiguate_hint_fn)(struct repository *, const struct object_id *, void *);
|
||||
|
||||
struct disambiguate_state {
|
||||
int len; /* length of prefix in hex chars */
|
||||
char hex_pfx[GIT_MAX_HEXSZ + 1];
|
||||
struct object_id bin_pfx;
|
||||
|
||||
struct repository *repo;
|
||||
disambiguate_hint_fn fn;
|
||||
void *cb_data;
|
||||
struct object_id candidate;
|
||||
|
|
@ -38,7 +40,7 @@ struct disambiguate_state {
|
|||
static void update_candidates(struct disambiguate_state *ds, const struct object_id *current)
|
||||
{
|
||||
if (ds->always_call_fn) {
|
||||
ds->ambiguous = ds->fn(current, ds->cb_data) ? 1 : 0;
|
||||
ds->ambiguous = ds->fn(ds->repo, current, ds->cb_data) ? 1 : 0;
|
||||
return;
|
||||
}
|
||||
if (!ds->candidate_exists) {
|
||||
|
|
@ -58,7 +60,7 @@ static void update_candidates(struct disambiguate_state *ds, const struct object
|
|||
}
|
||||
|
||||
if (!ds->candidate_checked) {
|
||||
ds->candidate_ok = ds->fn(&ds->candidate, ds->cb_data);
|
||||
ds->candidate_ok = ds->fn(ds->repo, &ds->candidate, ds->cb_data);
|
||||
ds->disambiguate_fn_used = 1;
|
||||
ds->candidate_checked = 1;
|
||||
}
|
||||
|
|
@ -71,7 +73,7 @@ static void update_candidates(struct disambiguate_state *ds, const struct object
|
|||
}
|
||||
|
||||
/* if we reach this point, we know ds->candidate satisfies fn */
|
||||
if (ds->fn(current, ds->cb_data)) {
|
||||
if (ds->fn(ds->repo, current, ds->cb_data)) {
|
||||
/*
|
||||
* if both current and candidate satisfy fn, we cannot
|
||||
* disambiguate.
|
||||
|
|
@ -89,9 +91,7 @@ static void find_short_object_filename(struct disambiguate_state *ds)
|
|||
{
|
||||
struct object_directory *odb;
|
||||
|
||||
for (odb = the_repository->objects->odb;
|
||||
odb && !ds->ambiguous;
|
||||
odb = odb->next) {
|
||||
for (odb = ds->repo->objects->odb; odb && !ds->ambiguous; odb = odb->next) {
|
||||
int pos;
|
||||
struct oid_array *loose_objects;
|
||||
|
||||
|
|
@ -182,10 +182,10 @@ static void find_short_packed_object(struct disambiguate_state *ds)
|
|||
struct multi_pack_index *m;
|
||||
struct packed_git *p;
|
||||
|
||||
for (m = get_multi_pack_index(the_repository); m && !ds->ambiguous;
|
||||
for (m = get_multi_pack_index(ds->repo); m && !ds->ambiguous;
|
||||
m = m->next)
|
||||
unique_in_midx(m, ds);
|
||||
for (p = get_packed_git(the_repository); p && !ds->ambiguous;
|
||||
for (p = get_packed_git(ds->repo); p && !ds->ambiguous;
|
||||
p = p->next)
|
||||
unique_in_pack(p, ds);
|
||||
}
|
||||
|
|
@ -215,7 +215,7 @@ static int finish_object_disambiguation(struct disambiguate_state *ds,
|
|||
* same repository!
|
||||
*/
|
||||
ds->candidate_ok = (!ds->disambiguate_fn_used ||
|
||||
ds->fn(&ds->candidate, ds->cb_data));
|
||||
ds->fn(ds->repo, &ds->candidate, ds->cb_data));
|
||||
|
||||
if (!ds->candidate_ok)
|
||||
return SHORT_NAME_AMBIGUOUS;
|
||||
|
|
@ -224,59 +224,67 @@ static int finish_object_disambiguation(struct disambiguate_state *ds,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int disambiguate_commit_only(const struct object_id *oid, void *cb_data_unused)
|
||||
static int disambiguate_commit_only(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
void *cb_data_unused)
|
||||
{
|
||||
int kind = oid_object_info(the_repository, oid, NULL);
|
||||
int kind = oid_object_info(r, oid, NULL);
|
||||
return kind == OBJ_COMMIT;
|
||||
}
|
||||
|
||||
static int disambiguate_committish_only(const struct object_id *oid, void *cb_data_unused)
|
||||
static int disambiguate_committish_only(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
void *cb_data_unused)
|
||||
{
|
||||
struct object *obj;
|
||||
int kind;
|
||||
|
||||
kind = oid_object_info(the_repository, oid, NULL);
|
||||
kind = oid_object_info(r, oid, NULL);
|
||||
if (kind == OBJ_COMMIT)
|
||||
return 1;
|
||||
if (kind != OBJ_TAG)
|
||||
return 0;
|
||||
|
||||
/* We need to do this the hard way... */
|
||||
obj = deref_tag(the_repository, parse_object(the_repository, oid),
|
||||
NULL, 0);
|
||||
obj = deref_tag(r, parse_object(r, oid), NULL, 0);
|
||||
if (obj && obj->type == OBJ_COMMIT)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int disambiguate_tree_only(const struct object_id *oid, void *cb_data_unused)
|
||||
static int disambiguate_tree_only(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
void *cb_data_unused)
|
||||
{
|
||||
int kind = oid_object_info(the_repository, oid, NULL);
|
||||
int kind = oid_object_info(r, oid, NULL);
|
||||
return kind == OBJ_TREE;
|
||||
}
|
||||
|
||||
static int disambiguate_treeish_only(const struct object_id *oid, void *cb_data_unused)
|
||||
static int disambiguate_treeish_only(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
void *cb_data_unused)
|
||||
{
|
||||
struct object *obj;
|
||||
int kind;
|
||||
|
||||
kind = oid_object_info(the_repository, oid, NULL);
|
||||
kind = oid_object_info(r, oid, NULL);
|
||||
if (kind == OBJ_TREE || kind == OBJ_COMMIT)
|
||||
return 1;
|
||||
if (kind != OBJ_TAG)
|
||||
return 0;
|
||||
|
||||
/* We need to do this the hard way... */
|
||||
obj = deref_tag(the_repository, parse_object(the_repository, oid),
|
||||
NULL, 0);
|
||||
obj = deref_tag(r, parse_object(r, oid), NULL, 0);
|
||||
if (obj && (obj->type == OBJ_TREE || obj->type == OBJ_COMMIT))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int disambiguate_blob_only(const struct object_id *oid, void *cb_data_unused)
|
||||
static int disambiguate_blob_only(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
void *cb_data_unused)
|
||||
{
|
||||
int kind = oid_object_info(the_repository, oid, NULL);
|
||||
int kind = oid_object_info(r, oid, NULL);
|
||||
return kind == OBJ_BLOB;
|
||||
}
|
||||
|
||||
|
|
@ -310,7 +318,8 @@ int set_disambiguate_hint_config(const char *var, const char *value)
|
|||
return error("unknown hint type for '%s': %s", var, value);
|
||||
}
|
||||
|
||||
static int init_object_disambiguation(const char *name, int len,
|
||||
static int init_object_disambiguation(struct repository *r,
|
||||
const char *name, int len,
|
||||
struct disambiguate_state *ds)
|
||||
{
|
||||
int i;
|
||||
|
|
@ -341,7 +350,8 @@ static int init_object_disambiguation(const char *name, int len,
|
|||
|
||||
ds->len = len;
|
||||
ds->hex_pfx[len] = '\0';
|
||||
prepare_alt_odb(the_repository);
|
||||
ds->repo = r;
|
||||
prepare_alt_odb(r);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -351,25 +361,25 @@ static int show_ambiguous_object(const struct object_id *oid, void *data)
|
|||
struct strbuf desc = STRBUF_INIT;
|
||||
int type;
|
||||
|
||||
if (ds->fn && !ds->fn(oid, ds->cb_data))
|
||||
if (ds->fn && !ds->fn(ds->repo, oid, ds->cb_data))
|
||||
return 0;
|
||||
|
||||
type = oid_object_info(the_repository, oid, NULL);
|
||||
type = oid_object_info(ds->repo, oid, NULL);
|
||||
if (type == OBJ_COMMIT) {
|
||||
struct commit *commit = lookup_commit(the_repository, oid);
|
||||
struct commit *commit = lookup_commit(ds->repo, 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(the_repository, oid);
|
||||
struct tag *tag = lookup_tag(ds->repo, oid);
|
||||
if (!parse_tag(tag) && tag->tag)
|
||||
strbuf_addf(&desc, " %s", tag->tag);
|
||||
}
|
||||
|
||||
advise(" %s %s%s",
|
||||
find_unique_abbrev(oid, DEFAULT_ABBREV),
|
||||
repo_find_unique_abbrev(ds->repo, oid, DEFAULT_ABBREV),
|
||||
type_name(type) ? type_name(type) : "unknown type",
|
||||
desc.buf);
|
||||
|
||||
|
|
@ -383,10 +393,18 @@ static int collect_ambiguous(const struct object_id *oid, void *data)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int repo_collect_ambiguous(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
void *data)
|
||||
{
|
||||
return collect_ambiguous(oid, data);
|
||||
}
|
||||
|
||||
static struct repository *sort_ambiguous_repo;
|
||||
static int sort_ambiguous(const void *a, const void *b)
|
||||
{
|
||||
int a_type = oid_object_info(the_repository, a, NULL);
|
||||
int b_type = oid_object_info(the_repository, b, NULL);
|
||||
int a_type = oid_object_info(sort_ambiguous_repo, a, NULL);
|
||||
int b_type = oid_object_info(sort_ambiguous_repo, b, NULL);
|
||||
int a_type_sort;
|
||||
int b_type_sort;
|
||||
|
||||
|
|
@ -411,7 +429,16 @@ static int sort_ambiguous(const void *a, const void *b)
|
|||
return a_type_sort > b_type_sort ? 1 : -1;
|
||||
}
|
||||
|
||||
static enum get_oid_result get_short_oid(const char *name, int len,
|
||||
static void sort_ambiguous_oid_array(struct repository *r, struct oid_array *a)
|
||||
{
|
||||
/* mutex will be needed if this code is to be made thread safe */
|
||||
sort_ambiguous_repo = r;
|
||||
QSORT(a->oid, a->nr, sort_ambiguous);
|
||||
sort_ambiguous_repo = NULL;
|
||||
}
|
||||
|
||||
static enum get_oid_result get_short_oid(struct repository *r,
|
||||
const char *name, int len,
|
||||
struct object_id *oid,
|
||||
unsigned flags)
|
||||
{
|
||||
|
|
@ -419,7 +446,7 @@ static enum get_oid_result get_short_oid(const char *name, int len,
|
|||
struct disambiguate_state ds;
|
||||
int quietly = !!(flags & GET_OID_QUIETLY);
|
||||
|
||||
if (init_object_disambiguation(name, len, &ds) < 0)
|
||||
if (init_object_disambiguation(r, name, len, &ds) < 0)
|
||||
return -1;
|
||||
|
||||
if (HAS_MULTI_BITS(flags & GET_OID_DISAMBIGUATORS))
|
||||
|
|
@ -469,8 +496,8 @@ static enum get_oid_result get_short_oid(const char *name, int len,
|
|||
ds.fn = NULL;
|
||||
|
||||
advise(_("The candidates are:"));
|
||||
for_each_abbrev(ds.hex_pfx, collect_ambiguous, &collect);
|
||||
QSORT(collect.oid, collect.nr, sort_ambiguous);
|
||||
repo_for_each_abbrev(r, ds.hex_pfx, collect_ambiguous, &collect);
|
||||
sort_ambiguous_oid_array(r, &collect);
|
||||
|
||||
if (oid_array_for_each(&collect, show_ambiguous_object, &ds))
|
||||
BUG("show_ambiguous_object shouldn't return non-zero");
|
||||
|
|
@ -480,17 +507,18 @@ static enum get_oid_result get_short_oid(const char *name, int len,
|
|||
return status;
|
||||
}
|
||||
|
||||
int for_each_abbrev(const char *prefix, each_abbrev_fn fn, void *cb_data)
|
||||
int repo_for_each_abbrev(struct repository *r, const char *prefix,
|
||||
each_abbrev_fn fn, void *cb_data)
|
||||
{
|
||||
struct oid_array collect = OID_ARRAY_INIT;
|
||||
struct disambiguate_state ds;
|
||||
int ret;
|
||||
|
||||
if (init_object_disambiguation(prefix, strlen(prefix), &ds) < 0)
|
||||
if (init_object_disambiguation(r, prefix, strlen(prefix), &ds) < 0)
|
||||
return -1;
|
||||
|
||||
ds.always_call_fn = 1;
|
||||
ds.fn = collect_ambiguous;
|
||||
ds.fn = repo_collect_ambiguous;
|
||||
ds.cb_data = &collect;
|
||||
find_short_object_filename(&ds);
|
||||
find_short_packed_object(&ds);
|
||||
|
|
@ -517,6 +545,7 @@ struct min_abbrev_data {
|
|||
unsigned int init_len;
|
||||
unsigned int cur_len;
|
||||
char *hex;
|
||||
struct repository *repo;
|
||||
const struct object_id *oid;
|
||||
};
|
||||
|
||||
|
|
@ -545,6 +574,13 @@ static int extend_abbrev_len(const struct object_id *oid, void *cb_data)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int repo_extend_abbrev_len(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
void *cb_data)
|
||||
{
|
||||
return extend_abbrev_len(oid, cb_data);
|
||||
}
|
||||
|
||||
static void find_abbrev_len_for_midx(struct multi_pack_index *m,
|
||||
struct min_abbrev_data *mad)
|
||||
{
|
||||
|
|
@ -622,21 +658,22 @@ static void find_abbrev_len_packed(struct min_abbrev_data *mad)
|
|||
struct multi_pack_index *m;
|
||||
struct packed_git *p;
|
||||
|
||||
for (m = get_multi_pack_index(the_repository); m; m = m->next)
|
||||
for (m = get_multi_pack_index(mad->repo); m; m = m->next)
|
||||
find_abbrev_len_for_midx(m, mad);
|
||||
for (p = get_packed_git(the_repository); p; p = p->next)
|
||||
for (p = get_packed_git(mad->repo); p; p = p->next)
|
||||
find_abbrev_len_for_pack(p, mad);
|
||||
}
|
||||
|
||||
int find_unique_abbrev_r(char *hex, const struct object_id *oid, int len)
|
||||
int repo_find_unique_abbrev_r(struct repository *r, char *hex,
|
||||
const struct object_id *oid, int len)
|
||||
{
|
||||
struct disambiguate_state ds;
|
||||
struct min_abbrev_data mad;
|
||||
struct object_id oid_ret;
|
||||
const unsigned hexsz = the_hash_algo->hexsz;
|
||||
const unsigned hexsz = r->hash_algo->hexsz;
|
||||
|
||||
if (len < 0) {
|
||||
unsigned long count = approximate_object_count();
|
||||
unsigned long count = repo_approximate_object_count(r);
|
||||
/*
|
||||
* Add one because the MSB only tells us the highest bit set,
|
||||
* not including the value of all the _other_ bits (so "15"
|
||||
|
|
@ -661,6 +698,7 @@ int find_unique_abbrev_r(char *hex, const struct object_id *oid, int len)
|
|||
if (len == hexsz || !len)
|
||||
return hexsz;
|
||||
|
||||
mad.repo = r;
|
||||
mad.init_len = len;
|
||||
mad.cur_len = len;
|
||||
mad.hex = hex;
|
||||
|
|
@ -668,10 +706,10 @@ int find_unique_abbrev_r(char *hex, const struct object_id *oid, int len)
|
|||
|
||||
find_abbrev_len_packed(&mad);
|
||||
|
||||
if (init_object_disambiguation(hex, mad.cur_len, &ds) < 0)
|
||||
if (init_object_disambiguation(r, hex, mad.cur_len, &ds) < 0)
|
||||
return -1;
|
||||
|
||||
ds.fn = extend_abbrev_len;
|
||||
ds.fn = repo_extend_abbrev_len;
|
||||
ds.always_call_fn = 1;
|
||||
ds.cb_data = (void *)&mad;
|
||||
|
||||
|
|
@ -682,13 +720,15 @@ int find_unique_abbrev_r(char *hex, const struct object_id *oid, int len)
|
|||
return mad.cur_len;
|
||||
}
|
||||
|
||||
const char *find_unique_abbrev(const struct object_id *oid, int len)
|
||||
const char *repo_find_unique_abbrev(struct repository *r,
|
||||
const struct object_id *oid,
|
||||
int len)
|
||||
{
|
||||
static int bufno;
|
||||
static char hexbuffer[4][GIT_MAX_HEXSZ + 1];
|
||||
char *hex = hexbuffer[bufno];
|
||||
bufno = (bufno + 1) % ARRAY_SIZE(hexbuffer);
|
||||
find_unique_abbrev_r(hex, oid, len);
|
||||
repo_find_unique_abbrev_r(r, hex, oid, len);
|
||||
return hex;
|
||||
}
|
||||
|
||||
|
|
@ -743,11 +783,11 @@ static inline int push_mark(const char *string, int len)
|
|||
return at_mark(string, len, suffix, ARRAY_SIZE(suffix));
|
||||
}
|
||||
|
||||
static enum get_oid_result get_oid_1(const char *name, int len, struct object_id *oid, unsigned lookup_flags);
|
||||
static int interpret_nth_prior_checkout(const char *name, int namelen, struct strbuf *buf);
|
||||
static enum get_oid_result get_oid_1(struct repository *r, const char *name, int len, struct object_id *oid, unsigned lookup_flags);
|
||||
static int interpret_nth_prior_checkout(struct repository *r, const char *name, int namelen, struct strbuf *buf);
|
||||
|
||||
static int get_oid_basic(const char *str, int len, struct object_id *oid,
|
||||
unsigned int flags)
|
||||
static int get_oid_basic(struct repository *r, const char *str, int len,
|
||||
struct object_id *oid, unsigned int flags)
|
||||
{
|
||||
static const char *warn_msg = "refname '%.*s' is ambiguous.";
|
||||
static const char *object_name_msg = N_(
|
||||
|
|
@ -765,9 +805,9 @@ static int get_oid_basic(const char *str, int len, struct object_id *oid,
|
|||
int refs_found = 0;
|
||||
int at, reflog_len, nth_prior = 0;
|
||||
|
||||
if (len == the_hash_algo->hexsz && !get_oid_hex(str, oid)) {
|
||||
if (len == r->hash_algo->hexsz && !get_oid_hex(str, oid)) {
|
||||
if (warn_ambiguous_refs && warn_on_object_refname_ambiguity) {
|
||||
refs_found = dwim_ref(str, len, &tmp_oid, &real_ref);
|
||||
refs_found = repo_dwim_ref(r, str, len, &tmp_oid, &real_ref);
|
||||
if (refs_found > 0) {
|
||||
warning(warn_msg, len, str);
|
||||
if (advice_object_name_warning)
|
||||
|
|
@ -808,8 +848,8 @@ static int get_oid_basic(const char *str, int len, struct object_id *oid,
|
|||
struct strbuf buf = STRBUF_INIT;
|
||||
int detached;
|
||||
|
||||
if (interpret_nth_prior_checkout(str, len, &buf) > 0) {
|
||||
detached = (buf.len == the_hash_algo->hexsz && !get_oid_hex(buf.buf, oid));
|
||||
if (interpret_nth_prior_checkout(r, str, len, &buf) > 0) {
|
||||
detached = (buf.len == r->hash_algo->hexsz && !get_oid_hex(buf.buf, oid));
|
||||
strbuf_release(&buf);
|
||||
if (detached)
|
||||
return 0;
|
||||
|
|
@ -818,18 +858,18 @@ static int get_oid_basic(const char *str, int len, struct object_id *oid,
|
|||
|
||||
if (!len && reflog_len)
|
||||
/* allow "@{...}" to mean the current branch reflog */
|
||||
refs_found = dwim_ref("HEAD", 4, oid, &real_ref);
|
||||
refs_found = repo_dwim_ref(r, "HEAD", 4, oid, &real_ref);
|
||||
else if (reflog_len)
|
||||
refs_found = dwim_log(str, len, oid, &real_ref);
|
||||
refs_found = repo_dwim_log(r, str, len, oid, &real_ref);
|
||||
else
|
||||
refs_found = dwim_ref(str, len, oid, &real_ref);
|
||||
refs_found = repo_dwim_ref(r, str, len, oid, &real_ref);
|
||||
|
||||
if (!refs_found)
|
||||
return -1;
|
||||
|
||||
if (warn_ambiguous_refs && !(flags & GET_OID_QUIETLY) &&
|
||||
(refs_found > 1 ||
|
||||
!get_short_oid(str, len, &tmp_oid, GET_OID_QUIETLY)))
|
||||
!get_short_oid(r, str, len, &tmp_oid, GET_OID_QUIETLY)))
|
||||
warning(warn_msg, len, str);
|
||||
|
||||
if (reflog_len) {
|
||||
|
|
@ -861,7 +901,8 @@ static int get_oid_basic(const char *str, int len, struct object_id *oid,
|
|||
return -1;
|
||||
}
|
||||
}
|
||||
if (read_ref_at(real_ref, flags, at_time, nth, oid, NULL,
|
||||
if (read_ref_at(get_main_ref_store(r),
|
||||
real_ref, flags, at_time, nth, oid, NULL,
|
||||
&co_time, &co_tz, &co_cnt)) {
|
||||
if (!len) {
|
||||
if (starts_with(real_ref, "refs/heads/")) {
|
||||
|
|
@ -893,18 +934,19 @@ static int get_oid_basic(const char *str, int len, struct object_id *oid,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static enum get_oid_result get_parent(const char *name, int len,
|
||||
static enum get_oid_result get_parent(struct repository *r,
|
||||
const char *name, int len,
|
||||
struct object_id *result, int idx)
|
||||
{
|
||||
struct object_id oid;
|
||||
enum get_oid_result ret = get_oid_1(name, len, &oid,
|
||||
enum get_oid_result ret = get_oid_1(r, name, len, &oid,
|
||||
GET_OID_COMMITTISH);
|
||||
struct commit *commit;
|
||||
struct commit_list *p;
|
||||
|
||||
if (ret)
|
||||
return ret;
|
||||
commit = lookup_commit_reference(the_repository, &oid);
|
||||
commit = lookup_commit_reference(r, &oid);
|
||||
if (parse_commit(commit))
|
||||
return MISSING_OBJECT;
|
||||
if (!idx) {
|
||||
|
|
@ -922,7 +964,8 @@ static enum get_oid_result get_parent(const char *name, int len,
|
|||
return MISSING_OBJECT;
|
||||
}
|
||||
|
||||
static enum get_oid_result get_nth_ancestor(const char *name, int len,
|
||||
static enum get_oid_result get_nth_ancestor(struct repository *r,
|
||||
const char *name, int len,
|
||||
struct object_id *result,
|
||||
int generation)
|
||||
{
|
||||
|
|
@ -930,10 +973,10 @@ static enum get_oid_result get_nth_ancestor(const char *name, int len,
|
|||
struct commit *commit;
|
||||
int ret;
|
||||
|
||||
ret = get_oid_1(name, len, &oid, GET_OID_COMMITTISH);
|
||||
ret = get_oid_1(r, name, len, &oid, GET_OID_COMMITTISH);
|
||||
if (ret)
|
||||
return ret;
|
||||
commit = lookup_commit_reference(the_repository, &oid);
|
||||
commit = lookup_commit_reference(r, &oid);
|
||||
if (!commit)
|
||||
return MISSING_OBJECT;
|
||||
|
||||
|
|
@ -946,20 +989,20 @@ static enum get_oid_result get_nth_ancestor(const char *name, int len,
|
|||
return FOUND;
|
||||
}
|
||||
|
||||
struct object *peel_to_type(const char *name, int namelen,
|
||||
struct object *o, enum object_type expected_type)
|
||||
struct object *repo_peel_to_type(struct repository *r, const char *name, int namelen,
|
||||
struct object *o, enum object_type expected_type)
|
||||
{
|
||||
if (name && !namelen)
|
||||
namelen = strlen(name);
|
||||
while (1) {
|
||||
if (!o || (!o->parsed && !parse_object(the_repository, &o->oid)))
|
||||
if (!o || (!o->parsed && !parse_object(r, &o->oid)))
|
||||
return NULL;
|
||||
if (expected_type == OBJ_ANY || o->type == expected_type)
|
||||
return o;
|
||||
if (o->type == OBJ_TAG)
|
||||
o = ((struct tag*) o)->tagged;
|
||||
else if (o->type == OBJ_COMMIT)
|
||||
o = &(get_commit_tree(((struct commit *)o))->object);
|
||||
o = &(repo_get_commit_tree(r, ((struct commit *)o))->object);
|
||||
else {
|
||||
if (name)
|
||||
error("%.*s: expected %s type, but the object "
|
||||
|
|
@ -971,8 +1014,8 @@ struct object *peel_to_type(const char *name, int namelen,
|
|||
}
|
||||
}
|
||||
|
||||
static int peel_onion(const char *name, int len, struct object_id *oid,
|
||||
unsigned lookup_flags)
|
||||
static int peel_onion(struct repository *r, const char *name, int len,
|
||||
struct object_id *oid, unsigned lookup_flags)
|
||||
{
|
||||
struct object_id outer;
|
||||
const char *sp;
|
||||
|
|
@ -1022,15 +1065,15 @@ static int peel_onion(const char *name, int len, struct object_id *oid,
|
|||
else if (expected_type == OBJ_TREE)
|
||||
lookup_flags |= GET_OID_TREEISH;
|
||||
|
||||
if (get_oid_1(name, sp - name - 2, &outer, lookup_flags))
|
||||
if (get_oid_1(r, name, sp - name - 2, &outer, lookup_flags))
|
||||
return -1;
|
||||
|
||||
o = parse_object(the_repository, &outer);
|
||||
o = parse_object(r, &outer);
|
||||
if (!o)
|
||||
return -1;
|
||||
if (!expected_type) {
|
||||
o = deref_tag(the_repository, o, name, sp - name - 2);
|
||||
if (!o || (!o->parsed && !parse_object(the_repository, &o->oid)))
|
||||
o = deref_tag(r, o, name, sp - name - 2);
|
||||
if (!o || (!o->parsed && !parse_object(r, &o->oid)))
|
||||
return -1;
|
||||
oidcpy(oid, &o->oid);
|
||||
return 0;
|
||||
|
|
@ -1041,7 +1084,7 @@ static int peel_onion(const char *name, int len, struct object_id *oid,
|
|||
* if we do not get the needed object, we should
|
||||
* barf.
|
||||
*/
|
||||
o = peel_to_type(name, len, o, expected_type);
|
||||
o = repo_peel_to_type(r, name, len, o, expected_type);
|
||||
if (!o)
|
||||
return -1;
|
||||
|
||||
|
|
@ -1061,14 +1104,16 @@ static int peel_onion(const char *name, int len, struct object_id *oid,
|
|||
|
||||
prefix = xstrndup(sp + 1, name + len - 1 - (sp + 1));
|
||||
commit_list_insert((struct commit *)o, &list);
|
||||
ret = get_oid_oneline(prefix, oid, list);
|
||||
ret = get_oid_oneline(r, prefix, oid, list);
|
||||
free(prefix);
|
||||
return ret;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int get_describe_name(const char *name, int len, struct object_id *oid)
|
||||
static int get_describe_name(struct repository *r,
|
||||
const char *name, int len,
|
||||
struct object_id *oid)
|
||||
{
|
||||
const char *cp;
|
||||
unsigned flags = GET_OID_QUIETLY | GET_OID_COMMIT;
|
||||
|
|
@ -1082,14 +1127,16 @@ static int get_describe_name(const char *name, int len, struct object_id *oid)
|
|||
if (ch == 'g' && cp[-1] == '-') {
|
||||
cp++;
|
||||
len -= cp - name;
|
||||
return get_short_oid(cp, len, oid, flags);
|
||||
return get_short_oid(r,
|
||||
cp, len, oid, flags);
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static enum get_oid_result get_oid_1(const char *name, int len,
|
||||
static enum get_oid_result get_oid_1(struct repository *r,
|
||||
const char *name, int len,
|
||||
struct object_id *oid,
|
||||
unsigned lookup_flags)
|
||||
{
|
||||
|
|
@ -1118,25 +1165,25 @@ static enum get_oid_result get_oid_1(const char *name, int len,
|
|||
if (!num && len1 == len - 1)
|
||||
num = 1;
|
||||
if (has_suffix == '^')
|
||||
return get_parent(name, len1, oid, num);
|
||||
return get_parent(r, name, len1, oid, num);
|
||||
/* else if (has_suffix == '~') -- goes without saying */
|
||||
return get_nth_ancestor(name, len1, oid, num);
|
||||
return get_nth_ancestor(r, name, len1, oid, num);
|
||||
}
|
||||
|
||||
ret = peel_onion(name, len, oid, lookup_flags);
|
||||
ret = peel_onion(r, name, len, oid, lookup_flags);
|
||||
if (!ret)
|
||||
return FOUND;
|
||||
|
||||
ret = get_oid_basic(name, len, oid, lookup_flags);
|
||||
ret = get_oid_basic(r, name, len, oid, lookup_flags);
|
||||
if (!ret)
|
||||
return FOUND;
|
||||
|
||||
/* It could be describe output that is "SOMETHING-gXXXX" */
|
||||
ret = get_describe_name(name, len, oid);
|
||||
ret = get_describe_name(r, name, len, oid);
|
||||
if (!ret)
|
||||
return FOUND;
|
||||
|
||||
return get_short_oid(name, len, oid, lookup_flags);
|
||||
return get_short_oid(r, name, len, oid, lookup_flags);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1155,15 +1202,21 @@ static enum get_oid_result get_oid_1(const char *name, int len,
|
|||
/* Remember to update object flag allocation in object.h */
|
||||
#define ONELINE_SEEN (1u<<20)
|
||||
|
||||
struct handle_one_ref_cb {
|
||||
struct repository *repo;
|
||||
struct commit_list **list;
|
||||
};
|
||||
|
||||
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(the_repository, oid);
|
||||
struct handle_one_ref_cb *cb = cb_data;
|
||||
struct commit_list **list = cb->list;
|
||||
struct object *object = parse_object(cb->repo, oid);
|
||||
if (!object)
|
||||
return 0;
|
||||
if (object->type == OBJ_TAG) {
|
||||
object = deref_tag(the_repository, object, path,
|
||||
object = deref_tag(cb->repo, object, path,
|
||||
strlen(path));
|
||||
if (!object)
|
||||
return 0;
|
||||
|
|
@ -1174,8 +1227,9 @@ static int handle_one_ref(const char *path, const struct object_id *oid,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int get_oid_oneline(const char *prefix, struct object_id *oid,
|
||||
struct commit_list *list)
|
||||
static int get_oid_oneline(struct repository *r,
|
||||
const char *prefix, struct object_id *oid,
|
||||
struct commit_list *list)
|
||||
{
|
||||
struct commit_list *backup = NULL, *l;
|
||||
int found = 0;
|
||||
|
|
@ -1206,7 +1260,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(the_repository, &commit->object.oid))
|
||||
if (!parse_object(r, &commit->object.oid))
|
||||
continue;
|
||||
buf = get_commit_buffer(commit, NULL);
|
||||
p = strstr(buf, "\n\n");
|
||||
|
|
@ -1258,7 +1312,8 @@ static int grab_nth_branch_switch(struct object_id *ooid, struct object_id *noid
|
|||
* Parse @{-N} syntax, return the number of characters parsed
|
||||
* if successful; otherwise signal an error with negative value.
|
||||
*/
|
||||
static int interpret_nth_prior_checkout(const char *name, int namelen,
|
||||
static int interpret_nth_prior_checkout(struct repository *r,
|
||||
const char *name, int namelen,
|
||||
struct strbuf *buf)
|
||||
{
|
||||
long nth;
|
||||
|
|
@ -1282,18 +1337,22 @@ static int interpret_nth_prior_checkout(const char *name, int namelen,
|
|||
cb.remaining = nth;
|
||||
strbuf_init(&cb.buf, 20);
|
||||
|
||||
retval = 0;
|
||||
if (0 < for_each_reflog_ent_reverse("HEAD", grab_nth_branch_switch, &cb)) {
|
||||
retval = refs_for_each_reflog_ent_reverse(get_main_ref_store(r),
|
||||
"HEAD", grab_nth_branch_switch, &cb);
|
||||
if (0 < retval) {
|
||||
strbuf_reset(buf);
|
||||
strbuf_addbuf(buf, &cb.buf);
|
||||
retval = brace - name + 1;
|
||||
}
|
||||
} else
|
||||
retval = 0;
|
||||
|
||||
strbuf_release(&cb.buf);
|
||||
return retval;
|
||||
}
|
||||
|
||||
int get_oid_mb(const char *name, struct object_id *oid)
|
||||
int repo_get_oid_mb(struct repository *r,
|
||||
const char *name,
|
||||
struct object_id *oid)
|
||||
{
|
||||
struct commit *one, *two;
|
||||
struct commit_list *mbs;
|
||||
|
|
@ -1303,27 +1362,29 @@ int get_oid_mb(const char *name, struct object_id *oid)
|
|||
|
||||
dots = strstr(name, "...");
|
||||
if (!dots)
|
||||
return get_oid(name, oid);
|
||||
return repo_get_oid(r, name, oid);
|
||||
if (dots == name)
|
||||
st = get_oid("HEAD", &oid_tmp);
|
||||
st = repo_get_oid(r, "HEAD", &oid_tmp);
|
||||
else {
|
||||
struct strbuf sb;
|
||||
strbuf_init(&sb, dots - name);
|
||||
strbuf_add(&sb, name, dots - name);
|
||||
st = get_oid_committish(sb.buf, &oid_tmp);
|
||||
st = repo_get_oid_committish(r, sb.buf, &oid_tmp);
|
||||
strbuf_release(&sb);
|
||||
}
|
||||
if (st)
|
||||
return st;
|
||||
one = lookup_commit_reference_gently(the_repository, &oid_tmp, 0);
|
||||
one = lookup_commit_reference_gently(r, &oid_tmp, 0);
|
||||
if (!one)
|
||||
return -1;
|
||||
|
||||
if (get_oid_committish(dots[3] ? (dots + 3) : "HEAD", &oid_tmp))
|
||||
if (repo_get_oid_committish(r, dots[3] ? (dots + 3) : "HEAD", &oid_tmp))
|
||||
return -1;
|
||||
two = lookup_commit_reference_gently(the_repository, &oid_tmp, 0);
|
||||
two = lookup_commit_reference_gently(r, &oid_tmp, 0);
|
||||
if (!two)
|
||||
return -1;
|
||||
if (r != the_repository)
|
||||
BUG("sorry get_merge_bases() can't take struct repository yet");
|
||||
mbs = get_merge_bases(one, two);
|
||||
if (!mbs || mbs->next)
|
||||
st = -1;
|
||||
|
|
@ -1357,7 +1418,8 @@ static int interpret_empty_at(const char *name, int namelen, int len, struct str
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int reinterpret(const char *name, int namelen, int len,
|
||||
static int reinterpret(struct repository *r,
|
||||
const char *name, int namelen, int len,
|
||||
struct strbuf *buf, unsigned allowed)
|
||||
{
|
||||
/* we have extra data, which might need further processing */
|
||||
|
|
@ -1366,7 +1428,7 @@ static int reinterpret(const char *name, int namelen, int len,
|
|||
int ret;
|
||||
|
||||
strbuf_add(buf, name + len, namelen - len);
|
||||
ret = interpret_branch_name(buf->buf, buf->len, &tmp, allowed);
|
||||
ret = repo_interpret_branch_name(r, buf->buf, buf->len, &tmp, allowed);
|
||||
/* that data was not interpreted, remove our cruft */
|
||||
if (ret < 0) {
|
||||
strbuf_setlen(buf, used);
|
||||
|
|
@ -1379,9 +1441,9 @@ static int reinterpret(const char *name, int namelen, int len,
|
|||
return ret - used + len;
|
||||
}
|
||||
|
||||
static void set_shortened_ref(struct strbuf *buf, const char *ref)
|
||||
static void set_shortened_ref(struct repository *r, struct strbuf *buf, const char *ref)
|
||||
{
|
||||
char *s = shorten_unambiguous_ref(ref, 0);
|
||||
char *s = refs_shorten_unambiguous_ref(get_main_ref_store(r), ref, 0);
|
||||
strbuf_reset(buf);
|
||||
strbuf_addstr(buf, s);
|
||||
free(s);
|
||||
|
|
@ -1402,7 +1464,8 @@ static int branch_interpret_allowed(const char *refname, unsigned allowed)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int interpret_branch_mark(const char *name, int namelen,
|
||||
static int interpret_branch_mark(struct repository *r,
|
||||
const char *name, int namelen,
|
||||
int at, struct strbuf *buf,
|
||||
int (*get_mark)(const char *, int),
|
||||
const char *(*get_data)(struct branch *,
|
||||
|
|
@ -1435,12 +1498,14 @@ static int interpret_branch_mark(const char *name, int namelen,
|
|||
if (!branch_interpret_allowed(value, allowed))
|
||||
return -1;
|
||||
|
||||
set_shortened_ref(buf, value);
|
||||
set_shortened_ref(r, buf, value);
|
||||
return len + at;
|
||||
}
|
||||
|
||||
int interpret_branch_name(const char *name, int namelen, struct strbuf *buf,
|
||||
unsigned allowed)
|
||||
int repo_interpret_branch_name(struct repository *r,
|
||||
const char *name, int namelen,
|
||||
struct strbuf *buf,
|
||||
unsigned allowed)
|
||||
{
|
||||
char *at;
|
||||
const char *start;
|
||||
|
|
@ -1450,14 +1515,14 @@ int interpret_branch_name(const char *name, int namelen, struct strbuf *buf,
|
|||
namelen = strlen(name);
|
||||
|
||||
if (!allowed || (allowed & INTERPRET_BRANCH_LOCAL)) {
|
||||
len = interpret_nth_prior_checkout(name, namelen, buf);
|
||||
len = interpret_nth_prior_checkout(r, name, namelen, buf);
|
||||
if (!len) {
|
||||
return len; /* syntax Ok, not enough switches */
|
||||
} else if (len > 0) {
|
||||
if (len == namelen)
|
||||
return len; /* consumed all */
|
||||
else
|
||||
return reinterpret(name, namelen, len, buf, allowed);
|
||||
return reinterpret(r, name, namelen, len, buf, allowed);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1468,17 +1533,17 @@ int interpret_branch_name(const char *name, int namelen, struct strbuf *buf,
|
|||
if (!allowed || (allowed & INTERPRET_BRANCH_HEAD)) {
|
||||
len = interpret_empty_at(name, namelen, at - name, buf);
|
||||
if (len > 0)
|
||||
return reinterpret(name, namelen, len, buf,
|
||||
return reinterpret(r, name, namelen, len, buf,
|
||||
allowed);
|
||||
}
|
||||
|
||||
len = interpret_branch_mark(name, namelen, at - name, buf,
|
||||
len = interpret_branch_mark(r, name, namelen, at - name, buf,
|
||||
upstream_mark, branch_get_upstream,
|
||||
allowed);
|
||||
if (len > 0)
|
||||
return len;
|
||||
|
||||
len = interpret_branch_mark(name, namelen, at - name, buf,
|
||||
len = interpret_branch_mark(r, name, namelen, at - name, buf,
|
||||
push_mark, branch_get_push,
|
||||
allowed);
|
||||
if (len > 0)
|
||||
|
|
@ -1524,10 +1589,10 @@ int strbuf_check_branch_ref(struct strbuf *sb, const char *name)
|
|||
* This is like "get_oid_basic()", except it allows "object ID expressions",
|
||||
* notably "xyz^" for "parent of xyz"
|
||||
*/
|
||||
int get_oid(const char *name, struct object_id *oid)
|
||||
int repo_get_oid(struct repository *r, const char *name, struct object_id *oid)
|
||||
{
|
||||
struct object_context unused;
|
||||
return get_oid_with_context(the_repository, name, 0, oid, &unused);
|
||||
return get_oid_with_context(r, name, 0, oid, &unused);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1560,43 +1625,48 @@ int get_oidf(struct object_id *oid, const char *fmt, ...)
|
|||
* commit-ish. It is merely to give a hint to the disambiguation
|
||||
* machinery.
|
||||
*/
|
||||
int get_oid_committish(const char *name, struct object_id *oid)
|
||||
int repo_get_oid_committish(struct repository *r,
|
||||
const char *name,
|
||||
struct object_id *oid)
|
||||
{
|
||||
struct object_context unused;
|
||||
return get_oid_with_context(the_repository,
|
||||
name, GET_OID_COMMITTISH,
|
||||
return get_oid_with_context(r, name, GET_OID_COMMITTISH,
|
||||
oid, &unused);
|
||||
}
|
||||
|
||||
int get_oid_treeish(const char *name, struct object_id *oid)
|
||||
int repo_get_oid_treeish(struct repository *r,
|
||||
const char *name,
|
||||
struct object_id *oid)
|
||||
{
|
||||
struct object_context unused;
|
||||
return get_oid_with_context(the_repository,
|
||||
name, GET_OID_TREEISH,
|
||||
return get_oid_with_context(r, name, GET_OID_TREEISH,
|
||||
oid, &unused);
|
||||
}
|
||||
|
||||
int get_oid_commit(const char *name, struct object_id *oid)
|
||||
int repo_get_oid_commit(struct repository *r,
|
||||
const char *name,
|
||||
struct object_id *oid)
|
||||
{
|
||||
struct object_context unused;
|
||||
return get_oid_with_context(the_repository,
|
||||
name, GET_OID_COMMIT,
|
||||
return get_oid_with_context(r, name, GET_OID_COMMIT,
|
||||
oid, &unused);
|
||||
}
|
||||
|
||||
int get_oid_tree(const char *name, struct object_id *oid)
|
||||
int repo_get_oid_tree(struct repository *r,
|
||||
const char *name,
|
||||
struct object_id *oid)
|
||||
{
|
||||
struct object_context unused;
|
||||
return get_oid_with_context(the_repository,
|
||||
name, GET_OID_TREE,
|
||||
return get_oid_with_context(r, name, GET_OID_TREE,
|
||||
oid, &unused);
|
||||
}
|
||||
|
||||
int get_oid_blob(const char *name, struct object_id *oid)
|
||||
int repo_get_oid_blob(struct repository *r,
|
||||
const char *name,
|
||||
struct object_id *oid)
|
||||
{
|
||||
struct object_context unused;
|
||||
return get_oid_with_context(the_repository,
|
||||
name, GET_OID_BLOB,
|
||||
return get_oid_with_context(r, name, GET_OID_BLOB,
|
||||
oid, &unused);
|
||||
}
|
||||
|
||||
|
|
@ -1635,11 +1705,12 @@ static void diagnose_invalid_oid_path(const char *prefix,
|
|||
}
|
||||
|
||||
/* Must be called only when :stage:filename doesn't exist. */
|
||||
static void diagnose_invalid_index_path(struct index_state *istate,
|
||||
static void diagnose_invalid_index_path(struct repository *r,
|
||||
int stage,
|
||||
const char *prefix,
|
||||
const char *filename)
|
||||
{
|
||||
struct index_state *istate = r->index;
|
||||
const struct cache_entry *ce;
|
||||
int pos;
|
||||
unsigned namelen = strlen(filename);
|
||||
|
|
@ -1679,7 +1750,7 @@ static void diagnose_invalid_index_path(struct index_state *istate,
|
|||
ce_stage(ce), filename);
|
||||
}
|
||||
|
||||
if (file_exists(filename))
|
||||
if (repo_file_exists(r, filename))
|
||||
die("Path '%s' exists on disk, but not in the index.", filename);
|
||||
if (is_missing_file_error(errno))
|
||||
die("Path '%s' does not exist (neither on disk nor in the index).",
|
||||
|
|
@ -1689,12 +1760,12 @@ static void diagnose_invalid_index_path(struct index_state *istate,
|
|||
}
|
||||
|
||||
|
||||
static char *resolve_relative_path(const char *rel)
|
||||
static char *resolve_relative_path(struct repository *r, const char *rel)
|
||||
{
|
||||
if (!starts_with(rel, "./") && !starts_with(rel, "../"))
|
||||
return NULL;
|
||||
|
||||
if (!is_inside_work_tree())
|
||||
if (r != the_repository || !is_inside_work_tree())
|
||||
die("relative path syntax can't be used outside working tree.");
|
||||
|
||||
/* die() inside prefix_path() if resolved path is outside worktree */
|
||||
|
|
@ -1721,7 +1792,7 @@ static enum get_oid_result get_oid_with_context_1(struct repository *repo,
|
|||
memset(oc, 0, sizeof(*oc));
|
||||
oc->mode = S_IFINVALID;
|
||||
strbuf_init(&oc->symlink_path, 0);
|
||||
ret = get_oid_1(name, namelen, oid, flags);
|
||||
ret = get_oid_1(repo, name, namelen, oid, flags);
|
||||
if (!ret)
|
||||
return ret;
|
||||
/*
|
||||
|
|
@ -1737,12 +1808,15 @@ static enum get_oid_result get_oid_with_context_1(struct repository *repo,
|
|||
char *new_path = NULL;
|
||||
int pos;
|
||||
if (!only_to_die && namelen > 2 && name[1] == '/') {
|
||||
struct handle_one_ref_cb cb;
|
||||
struct commit_list *list = NULL;
|
||||
|
||||
for_each_ref(handle_one_ref, &list);
|
||||
head_ref(handle_one_ref, &list);
|
||||
cb.repo = repo;
|
||||
cb.list = &list;
|
||||
refs_for_each_ref(repo->refs, handle_one_ref, &cb);
|
||||
refs_head_ref(repo->refs, handle_one_ref, &cb);
|
||||
commit_list_sort_by_date(&list);
|
||||
return get_oid_oneline(name + 2, oid, list);
|
||||
return get_oid_oneline(repo, name + 2, oid, list);
|
||||
}
|
||||
if (namelen < 3 ||
|
||||
name[2] != ':' ||
|
||||
|
|
@ -1752,7 +1826,7 @@ static enum get_oid_result get_oid_with_context_1(struct repository *repo,
|
|||
stage = name[1] - '0';
|
||||
cp = name + 3;
|
||||
}
|
||||
new_path = resolve_relative_path(cp);
|
||||
new_path = resolve_relative_path(repo, cp);
|
||||
if (!new_path) {
|
||||
namelen = namelen - (cp - name);
|
||||
} else {
|
||||
|
|
@ -1764,7 +1838,7 @@ static enum get_oid_result get_oid_with_context_1(struct repository *repo,
|
|||
oc->path = xstrdup(cp);
|
||||
|
||||
if (!repo->index->cache)
|
||||
repo_read_index(the_repository);
|
||||
repo_read_index(repo);
|
||||
pos = index_name_pos(repo->index, cp, namelen);
|
||||
if (pos < 0)
|
||||
pos = -pos - 1;
|
||||
|
|
@ -1782,7 +1856,7 @@ static enum get_oid_result get_oid_with_context_1(struct repository *repo,
|
|||
pos++;
|
||||
}
|
||||
if (only_to_die && name[1] && name[1] != '/')
|
||||
diagnose_invalid_index_path(repo->index, stage, prefix, cp);
|
||||
diagnose_invalid_index_path(repo, stage, prefix, cp);
|
||||
free(new_path);
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -1802,13 +1876,21 @@ static enum get_oid_result get_oid_with_context_1(struct repository *repo,
|
|||
sub_flags &= ~GET_OID_DISAMBIGUATORS;
|
||||
sub_flags |= GET_OID_TREEISH;
|
||||
|
||||
if (!get_oid_1(name, len, &tree_oid, sub_flags)) {
|
||||
if (!get_oid_1(repo, name, len, &tree_oid, sub_flags)) {
|
||||
const char *filename = cp+1;
|
||||
char *new_filename = NULL;
|
||||
|
||||
new_filename = resolve_relative_path(filename);
|
||||
new_filename = resolve_relative_path(repo, filename);
|
||||
if (new_filename)
|
||||
filename = new_filename;
|
||||
/*
|
||||
* NEEDSWORK: Eventually get_tree_entry*() should
|
||||
* learn to take struct repository directly and we
|
||||
* would not need to inject submodule odb to the
|
||||
* in-core odb.
|
||||
*/
|
||||
if (repo != the_repository)
|
||||
add_to_alternates_memory(repo->objects->odb->path);
|
||||
if (flags & GET_OID_FOLLOW_SYMLINKS) {
|
||||
ret = get_tree_entry_follow_symlinks(&tree_oid,
|
||||
filename, oid, &oc->symlink_path,
|
||||
|
|
@ -1843,11 +1925,13 @@ static enum get_oid_result get_oid_with_context_1(struct repository *repo,
|
|||
* exist in 'HEAD'" when given "HEAD:doc", or it may return in which case
|
||||
* you have a chance to diagnose the error further.
|
||||
*/
|
||||
void maybe_die_on_misspelt_object_name(const char *name, const char *prefix)
|
||||
void maybe_die_on_misspelt_object_name(struct repository *r,
|
||||
const char *name,
|
||||
const char *prefix)
|
||||
{
|
||||
struct object_context oc;
|
||||
struct object_id oid;
|
||||
get_oid_with_context_1(the_repository, name, GET_OID_ONLY_TO_DIE,
|
||||
get_oid_with_context_1(r, name, GET_OID_ONLY_TO_DIE,
|
||||
prefix, &oid, &oc);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -625,23 +625,16 @@ static void config_from_gitmodules(config_fn_t fn, struct repository *repo, void
|
|||
const struct config_options opts = { 0 };
|
||||
struct object_id oid;
|
||||
char *file;
|
||||
char *oidstr = NULL;
|
||||
|
||||
file = repo_worktree_path(repo, GITMODULES_FILE);
|
||||
if (file_exists(file)) {
|
||||
config_source.file = file;
|
||||
} else if (repo->submodule_prefix) {
|
||||
/*
|
||||
* When get_oid and config_with_options, used below,
|
||||
* become able to work on a specific repository, this
|
||||
* warning branch can be removed.
|
||||
*/
|
||||
warning("nested submodules without %s in the working tree are not supported yet",
|
||||
GITMODULES_FILE);
|
||||
goto out;
|
||||
} else if (get_oid(GITMODULES_INDEX, &oid) >= 0) {
|
||||
config_source.blob = GITMODULES_INDEX;
|
||||
} else if (get_oid(GITMODULES_HEAD, &oid) >= 0) {
|
||||
config_source.blob = GITMODULES_HEAD;
|
||||
} else if (repo_get_oid(repo, GITMODULES_INDEX, &oid) >= 0 ||
|
||||
repo_get_oid(repo, GITMODULES_HEAD, &oid) >= 0) {
|
||||
config_source.blob = oidstr = xstrdup(oid_to_hex(&oid));
|
||||
if (repo != the_repository)
|
||||
add_to_alternates_memory(repo->objects->odb->path);
|
||||
} else {
|
||||
goto out;
|
||||
}
|
||||
|
|
@ -649,6 +642,7 @@ static void config_from_gitmodules(config_fn_t fn, struct repository *repo, void
|
|||
config_with_options(fn, data, &config_source, &opts);
|
||||
|
||||
out:
|
||||
free(oidstr);
|
||||
free(file);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -380,11 +380,7 @@ test_expect_success 'grep --recurse-submodules should pass the pattern type alon
|
|||
fi
|
||||
'
|
||||
|
||||
# Recursing down into nested submodules which do not have .gitmodules in their
|
||||
# working tree does not work yet. This is because config_from_gitmodules()
|
||||
# uses get_oid() and the latter is still not able to get objects from an
|
||||
# arbitrary repository (the nested submodule, in this case).
|
||||
test_expect_failure 'grep --recurse-submodules with submodules without .gitmodules in the working tree' '
|
||||
test_expect_success 'grep --recurse-submodules with submodules without .gitmodules in the working tree' '
|
||||
test_when_finished "git -C submodule checkout .gitmodules" &&
|
||||
rm submodule/.gitmodules &&
|
||||
git grep --recurse-submodules -e "(.|.)[\d]" >actual &&
|
||||
|
|
|
|||
|
|
@ -839,7 +839,7 @@ static int process_deepen_not(const char *line, struct string_list *deepen_not,
|
|||
if (skip_prefix(line, "deepen-not ", &arg)) {
|
||||
char *ref = NULL;
|
||||
struct object_id oid;
|
||||
if (expand_ref(arg, strlen(arg), &oid, &ref) != 1)
|
||||
if (expand_ref(the_repository, arg, strlen(arg), &oid, &ref) != 1)
|
||||
die("git upload-pack: ambiguous deepen-not: %s", line);
|
||||
string_list_append(deepen_not, ref);
|
||||
free(ref);
|
||||
|
|
|
|||
Loading…
Reference in New Issue