https://github.com/git/git
Revision ac86677afb12947efb32668a6ae3cf8eaa7a1627 authored by Junio C Hamano on 18 October 2017, 05:19:14 UTC, committed by Junio C Hamano on 18 October 2017, 05:19:14 UTC
* rs/rs-mailmap: .mailmap: normalize name for René Scharfe
Tip revision: ac86677afb12947efb32668a6ae3cf8eaa7a1627 authored by Junio C Hamano on 18 October 2017, 05:19:14 UTC
Merge branch 'rs/rs-mailmap' into maint
Merge branch 'rs/rs-mailmap' into maint
Tip revision: ac86677
repository.c
#include "cache.h"
#include "repository.h"
#include "config.h"
#include "submodule-config.h"
/* The main repository */
static struct repository the_repo;
struct repository *the_repository = &the_repo;
static char *git_path_from_env(const char *envvar, const char *git_dir,
const char *path, int fromenv)
{
if (fromenv) {
const char *value = getenv(envvar);
if (value)
return xstrdup(value);
}
return xstrfmt("%s/%s", git_dir, path);
}
static int find_common_dir(struct strbuf *sb, const char *gitdir, int fromenv)
{
if (fromenv) {
const char *value = getenv(GIT_COMMON_DIR_ENVIRONMENT);
if (value) {
strbuf_addstr(sb, value);
return 1;
}
}
return get_common_dir_noenv(sb, gitdir);
}
static void repo_setup_env(struct repository *repo)
{
struct strbuf sb = STRBUF_INIT;
repo->different_commondir = find_common_dir(&sb, repo->gitdir,
!repo->ignore_env);
repo->commondir = strbuf_detach(&sb, NULL);
repo->objectdir = git_path_from_env(DB_ENVIRONMENT, repo->commondir,
"objects", !repo->ignore_env);
repo->graft_file = git_path_from_env(GRAFT_ENVIRONMENT, repo->commondir,
"info/grafts", !repo->ignore_env);
repo->index_file = git_path_from_env(INDEX_ENVIRONMENT, repo->gitdir,
"index", !repo->ignore_env);
}
void repo_set_gitdir(struct repository *repo, const char *path)
{
const char *gitfile = read_gitfile(path);
/*
* NEEDSWORK: Eventually we want to be able to free gitdir and the rest
* of the environment before reinitializing it again, but we have some
* crazy code paths where we try to set gitdir with the current gitdir
* and we don't want to free gitdir before copying the passed in value.
*/
repo->gitdir = xstrdup(gitfile ? gitfile : path);
repo_setup_env(repo);
}
/*
* Attempt to resolve and set the provided 'gitdir' for repository 'repo'.
* Return 0 upon success and a non-zero value upon failure.
*/
static int repo_init_gitdir(struct repository *repo, const char *gitdir)
{
int ret = 0;
int error = 0;
char *abspath = NULL;
const char *resolved_gitdir;
abspath = real_pathdup(gitdir, 0);
if (!abspath) {
ret = -1;
goto out;
}
/* 'gitdir' must reference the gitdir directly */
resolved_gitdir = resolve_gitdir_gently(abspath, &error);
if (!resolved_gitdir) {
ret = -1;
goto out;
}
repo_set_gitdir(repo, resolved_gitdir);
out:
free(abspath);
return ret;
}
void repo_set_worktree(struct repository *repo, const char *path)
{
repo->worktree = real_pathdup(path, 1);
}
static int read_and_verify_repository_format(struct repository_format *format,
const char *commondir)
{
int ret = 0;
struct strbuf sb = STRBUF_INIT;
strbuf_addf(&sb, "%s/config", commondir);
read_repository_format(format, sb.buf);
strbuf_reset(&sb);
if (verify_repository_format(format, &sb) < 0) {
warning("%s", sb.buf);
ret = -1;
}
strbuf_release(&sb);
return ret;
}
/*
* Initialize 'repo' based on the provided 'gitdir'.
* Return 0 upon success and a non-zero value upon failure.
*/
int repo_init(struct repository *repo, const char *gitdir, const char *worktree)
{
struct repository_format format;
memset(repo, 0, sizeof(*repo));
repo->ignore_env = 1;
if (repo_init_gitdir(repo, gitdir))
goto error;
if (read_and_verify_repository_format(&format, repo->commondir))
goto error;
if (worktree)
repo_set_worktree(repo, worktree);
return 0;
error:
repo_clear(repo);
return -1;
}
/*
* Initialize 'submodule' as the submodule given by 'path' in parent repository
* 'superproject'.
* Return 0 upon success and a non-zero value upon failure.
*/
int repo_submodule_init(struct repository *submodule,
struct repository *superproject,
const char *path)
{
const struct submodule *sub;
struct strbuf gitdir = STRBUF_INIT;
struct strbuf worktree = STRBUF_INIT;
int ret = 0;
sub = submodule_from_cache(superproject, null_sha1, path);
if (!sub) {
ret = -1;
goto out;
}
strbuf_repo_worktree_path(&gitdir, superproject, "%s/.git", path);
strbuf_repo_worktree_path(&worktree, superproject, "%s", path);
if (repo_init(submodule, gitdir.buf, worktree.buf)) {
/*
* If initilization fails then it may be due to the submodule
* not being populated in the superproject's worktree. Instead
* we can try to initilize the submodule by finding it's gitdir
* in the superproject's 'modules' directory. In this case the
* submodule would not have a worktree.
*/
strbuf_reset(&gitdir);
strbuf_repo_git_path(&gitdir, superproject,
"modules/%s", sub->name);
if (repo_init(submodule, gitdir.buf, NULL)) {
ret = -1;
goto out;
}
}
submodule->submodule_prefix = xstrfmt("%s%s/",
superproject->submodule_prefix ?
superproject->submodule_prefix :
"", path);
out:
strbuf_release(&gitdir);
strbuf_release(&worktree);
return ret;
}
void repo_clear(struct repository *repo)
{
free(repo->gitdir);
repo->gitdir = NULL;
free(repo->commondir);
repo->commondir = NULL;
free(repo->objectdir);
repo->objectdir = NULL;
free(repo->graft_file);
repo->graft_file = NULL;
free(repo->index_file);
repo->index_file = NULL;
free(repo->worktree);
repo->worktree = NULL;
free(repo->submodule_prefix);
repo->submodule_prefix = NULL;
if (repo->config) {
git_configset_clear(repo->config);
free(repo->config);
repo->config = NULL;
}
if (repo->submodule_cache) {
submodule_cache_free(repo->submodule_cache);
repo->submodule_cache = NULL;
}
if (repo->index) {
discard_index(repo->index);
free(repo->index);
repo->index = NULL;
}
}
int repo_read_index(struct repository *repo)
{
if (!repo->index)
repo->index = xcalloc(1, sizeof(*repo->index));
else
discard_index(repo->index);
return read_index_from(repo->index, repo->index_file);
}
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...