kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

builtin: stop using `the_index` 

Convert builtins to use `the_repository->index` instead of `the_index`.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Patrick Steinhardt 2024-04-18 14:14:14 +02:00 committed by Junio C Hamano
parent 319ba14407
commit f59aa5e0a9
28 changed files with 356 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
builtin/add.c
View File

@ -3,7 +3,7 @@
* *
* Copyright (C) 2006 Linus Torvalds * Copyright (C) 2006 Linus Torvalds
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "advice.h" #include "advice.h"
#include "config.h" #include "config.h"
@ -40,20 +40,20 @@ static int chmod_pathspec(struct pathspec *pathspec, char flip, int show_only)
{ {
int i, ret = 0; int i, ret = 0;


for (i = 0; i < the_index.cache_nr; i++) { for (i = 0; i < the_repository->index->cache_nr; i++) {
struct cache_entry *ce = the_index.cache[i]; struct cache_entry *ce = the_repository->index->cache[i];
int err; int err;


if (!include_sparse && if (!include_sparse &&
(ce_skip_worktree(ce) || (ce_skip_worktree(ce) ||
!path_in_sparse_checkout(ce->name, &the_index))) !path_in_sparse_checkout(ce->name, the_repository->index)))
continue; continue;


if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL)) if (pathspec && !ce_path_match(the_repository->index, ce, pathspec, NULL))
continue; continue;


if (!show_only) if (!show_only)
err = chmod_index_entry(&the_index, ce, flip); err = chmod_index_entry(the_repository->index, ce, flip);
else else
err = S_ISREG(ce->ce_mode) ? 0 : -1; err = S_ISREG(ce->ce_mode) ? 0 : -1;


@ -68,20 +68,20 @@ static int renormalize_tracked_files(const struct pathspec *pathspec, int flags)
{ {
int i, retval = 0; int i, retval = 0;


for (i = 0; i < the_index.cache_nr; i++) { for (i = 0; i < the_repository->index->cache_nr; i++) {
struct cache_entry *ce = the_index.cache[i]; struct cache_entry *ce = the_repository->index->cache[i];


if (!include_sparse && if (!include_sparse &&
(ce_skip_worktree(ce) || (ce_skip_worktree(ce) ||
!path_in_sparse_checkout(ce->name, &the_index))) !path_in_sparse_checkout(ce->name, the_repository->index)))
continue; continue;
if (ce_stage(ce)) if (ce_stage(ce))
continue; /* do not touch unmerged paths */ continue; /* do not touch unmerged paths */
if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode)) if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode))
continue; /* do not touch non blobs */ continue; /* do not touch non blobs */
if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL)) if (pathspec && !ce_path_match(the_repository->index, ce, pathspec, NULL))
continue; continue;
retval |= add_file_to_index(&the_index, ce->name, retval |= add_file_to_index(the_repository->index, ce->name,
flags | ADD_CACHE_RENORMALIZE); flags | ADD_CACHE_RENORMALIZE);
} }


@ -100,11 +100,11 @@ static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec,
i = dir->nr; i = dir->nr;
while (--i >= 0) { while (--i >= 0) {
struct dir_entry *entry = *src++; struct dir_entry *entry = *src++;
if (dir_path_match(&the_index, entry, pathspec, prefix, seen)) if (dir_path_match(the_repository->index, entry, pathspec, prefix, seen))
*dst++ = entry; *dst++ = entry;
} }
dir->nr = dst - dir->entries; dir->nr = dst - dir->entries;
add_pathspec_matches_against_index(pathspec, &the_index, seen, add_pathspec_matches_against_index(pathspec, the_repository->index, seen,
PS_IGNORE_SKIP_WORKTREE); PS_IGNORE_SKIP_WORKTREE);
return seen; return seen;
} }
@ -119,14 +119,14 @@ static int refresh(int verbose, const struct pathspec *pathspec)
(verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET); (verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET);


seen = xcalloc(pathspec->nr, 1); seen = xcalloc(pathspec->nr, 1);
refresh_index(&the_index, flags, pathspec, seen, refresh_index(the_repository->index, flags, pathspec, seen,
_("Unstaged changes after refreshing the index:")); _("Unstaged changes after refreshing the index:"));
for (i = 0; i < pathspec->nr; i++) { for (i = 0; i < pathspec->nr; i++) {
if (!seen[i]) { if (!seen[i]) {
const char *path = pathspec->items[i].original; const char *path = pathspec->items[i].original;


if (matches_skip_worktree(pathspec, i, &skip_worktree_seen) || if (matches_skip_worktree(pathspec, i, &skip_worktree_seen) ||
!path_in_sparse_checkout(path, &the_index)) { !path_in_sparse_checkout(path, the_repository->index)) {
string_list_append(&only_match_skip_worktree, string_list_append(&only_match_skip_worktree,
pathspec->items[i].original); pathspec->items[i].original);
} else { } else {
@ -335,12 +335,12 @@ static int add_files(struct dir_struct *dir, int flags)


for (i = 0; i < dir->nr; i++) { for (i = 0; i < dir->nr; i++) {
if (!include_sparse && if (!include_sparse &&
!path_in_sparse_checkout(dir->entries[i]->name, &the_index)) { !path_in_sparse_checkout(dir->entries[i]->name, the_repository->index)) {
string_list_append(&matched_sparse_paths, string_list_append(&matched_sparse_paths,
dir->entries[i]->name); dir->entries[i]->name);
continue; continue;
} }
if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) { if (add_file_to_index(the_repository->index, dir->entries[i]->name, flags)) {
if (!ignore_add_errors) if (!ignore_add_errors)
die(_("adding files failed")); die(_("adding files failed"));
exit_status = 1; exit_status = 1;
@ -458,8 +458,8 @@ int cmd_add(int argc, const char **argv, const char *prefix)
if (repo_read_index_preload(the_repository, &pathspec, 0) < 0) if (repo_read_index_preload(the_repository, &pathspec, 0) < 0)
die(_("index file corrupt")); die(_("index file corrupt"));


die_in_unpopulated_submodule(&the_index, prefix); die_in_unpopulated_submodule(the_repository->index, prefix);
die_path_inside_submodule(&the_index, &pathspec); die_path_inside_submodule(the_repository->index, &pathspec);


if (add_new_files) { if (add_new_files) {
int baselen; int baselen;
@ -471,7 +471,7 @@ int cmd_add(int argc, const char **argv, const char *prefix)
} }


/* This picks up the paths that are not tracked */ /* This picks up the paths that are not tracked */
baselen = fill_directory(&dir, &the_index, &pathspec); baselen = fill_directory(&dir, the_repository->index, &pathspec);
if (pathspec.nr) if (pathspec.nr)
seen = prune_directory(&dir, &pathspec, baselen); seen = prune_directory(&dir, &pathspec, baselen);
} }
@ -488,7 +488,7 @@ int cmd_add(int argc, const char **argv, const char *prefix)


if (!seen) if (!seen)
seen = find_pathspecs_matching_against_index(&pathspec, seen = find_pathspecs_matching_against_index(&pathspec,
&the_index, PS_IGNORE_SKIP_WORKTREE); the_repository->index, PS_IGNORE_SKIP_WORKTREE);


/* /*
* file_exists() assumes exact match * file_exists() assumes exact match
@ -524,8 +524,8 @@ int cmd_add(int argc, const char **argv, const char *prefix)
!file_exists(path)) { !file_exists(path)) {
if (ignore_missing) { if (ignore_missing) {
int dtype = DT_UNKNOWN; int dtype = DT_UNKNOWN;
if (is_excluded(&dir, &the_index, path, &dtype)) if (is_excluded(&dir, the_repository->index, path, &dtype))
dir_add_ignored(&dir, &the_index, dir_add_ignored(&dir, the_repository->index,
path, pathspec.items[i].len); path, pathspec.items[i].len);
} else } else
die(_("pathspec '%s' did not match any files"), die(_("pathspec '%s' did not match any files"),
@ -566,7 +566,7 @@ int cmd_add(int argc, const char **argv, const char *prefix)
end_odb_transaction(); end_odb_transaction();


finish: finish:
if (write_locked_index(&the_index, &lock_file, if (write_locked_index(the_repository->index, &lock_file,
COMMIT_LOCK | SKIP_IF_UNCHANGED)) COMMIT_LOCK | SKIP_IF_UNCHANGED))
die(_("unable to write new index file")); die(_("unable to write new index file"));



36
builtin/am.c
View File

@ -3,7 +3,7 @@
* *
* Based on git-am.sh by Junio C Hamano. * Based on git-am.sh by Junio C Hamano.
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "advice.h" #include "advice.h"
@ -1536,8 +1536,8 @@ static int run_apply(const struct am_state *state, const char *index_file)


if (index_file) { if (index_file) {
/* Reload index as apply_all_patches() will have modified it. */ /* Reload index as apply_all_patches() will have modified it. */
discard_index(&the_index); discard_index(the_repository->index);
read_index_from(&the_index, index_file, get_git_dir()); read_index_from(the_repository->index, index_file, get_git_dir());
} }


return 0; return 0;
@ -1579,10 +1579,10 @@ static int fall_back_threeway(const struct am_state *state, const char *index_pa
if (build_fake_ancestor(state, index_path)) if (build_fake_ancestor(state, index_path))
return error("could not build fake ancestor"); return error("could not build fake ancestor");


discard_index(&the_index); discard_index(the_repository->index);
read_index_from(&the_index, index_path, get_git_dir()); read_index_from(the_repository->index, index_path, get_git_dir());


if (write_index_as_tree(&orig_tree, &the_index, index_path, 0, NULL)) if (write_index_as_tree(&orig_tree, the_repository->index, index_path, 0, NULL))
return error(_("Repository lacks necessary blobs to fall back on 3-way merge.")); return error(_("Repository lacks necessary blobs to fall back on 3-way merge."));


say(state, stdout, _("Using index info to reconstruct a base tree...")); say(state, stdout, _("Using index info to reconstruct a base tree..."));
@ -1608,12 +1608,12 @@ static int fall_back_threeway(const struct am_state *state, const char *index_pa
return error(_("Did you hand edit your patch?\n" return error(_("Did you hand edit your patch?\n"
"It does not apply to blobs recorded in its index.")); "It does not apply to blobs recorded in its index."));


if (write_index_as_tree(&their_tree, &the_index, index_path, 0, NULL)) if (write_index_as_tree(&their_tree, the_repository->index, index_path, 0, NULL))
return error("could not write tree"); return error("could not write tree");


say(state, stdout, _("Falling back to patching base and 3-way merge...")); say(state, stdout, _("Falling back to patching base and 3-way merge..."));


discard_index(&the_index); discard_index(the_repository->index);
repo_read_index(the_repository); repo_read_index(the_repository);


/* /*
@ -1660,7 +1660,7 @@ static void do_commit(const struct am_state *state)
if (!state->no_verify && run_hooks("pre-applypatch")) if (!state->no_verify && run_hooks("pre-applypatch"))
exit(1); exit(1);


if (write_index_as_tree(&tree, &the_index, get_index_file(), 0, NULL)) if (write_index_as_tree(&tree, the_repository->index, get_index_file(), 0, NULL))
die(_("git write-tree failed to write a tree")); die(_("git write-tree failed to write a tree"));


if (!repo_get_oid_commit(the_repository, "HEAD", &parent)) { if (!repo_get_oid_commit(the_repository, "HEAD", &parent)) {
@ -1948,7 +1948,7 @@ static void am_resolve(struct am_state *state, int allow_empty)
} }
} }


if (unmerged_index(&the_index)) { if (unmerged_index(the_repository->index)) {
printf_ln(_("You still have unmerged paths in your index.\n" printf_ln(_("You still have unmerged paths in your index.\n"
"You should 'git add' each file with resolved conflicts to mark them as such.\n" "You should 'git add' each file with resolved conflicts to mark them as such.\n"
"You might run `git rm` on a file to accept \"deleted by them\" for it.")); "You might run `git rm` on a file to accept \"deleted by them\" for it."));
@ -1987,12 +1987,12 @@ static int fast_forward_to(struct tree *head, struct tree *remote, int reset)


repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR); repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);


refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL); refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL);


memset(&opts, 0, sizeof(opts)); memset(&opts, 0, sizeof(opts));
opts.head_idx = 1; opts.head_idx = 1;
opts.src_index = &the_index; opts.src_index = the_repository->index;
opts.dst_index = &the_index; opts.dst_index = the_repository->index;
opts.update = 1; opts.update = 1;
opts.merge = 1; opts.merge = 1;
opts.reset = reset ? UNPACK_RESET_PROTECT_UNTRACKED : 0; opts.reset = reset ? UNPACK_RESET_PROTECT_UNTRACKED : 0;
@ -2006,7 +2006,7 @@ static int fast_forward_to(struct tree *head, struct tree *remote, int reset)
return -1; return -1;
} }


if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
die(_("unable to write new index file")); die(_("unable to write new index file"));


return 0; return 0;
@ -2029,8 +2029,8 @@ static int merge_tree(struct tree *tree)


memset(&opts, 0, sizeof(opts)); memset(&opts, 0, sizeof(opts));
opts.head_idx = 1; opts.head_idx = 1;
opts.src_index = &the_index; opts.src_index = the_repository->index;
opts.dst_index = &the_index; opts.dst_index = the_repository->index;
opts.merge = 1; opts.merge = 1;
opts.fn = oneway_merge; opts.fn = oneway_merge;
init_tree_desc(&t[0], &tree->object.oid, tree->buffer, tree->size); init_tree_desc(&t[0], &tree->object.oid, tree->buffer, tree->size);
@ -2040,7 +2040,7 @@ static int merge_tree(struct tree *tree)
return -1; return -1;
} }


if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
die(_("unable to write new index file")); die(_("unable to write new index file"));


return 0; return 0;
@ -2068,7 +2068,7 @@ static int clean_index(const struct object_id *head, const struct object_id *rem
if (fast_forward_to(head_tree, head_tree, 1)) if (fast_forward_to(head_tree, head_tree, 1))
return -1; return -1;


if (write_index_as_tree(&index, &the_index, get_index_file(), 0, NULL)) if (write_index_as_tree(&index, the_repository->index, get_index_file(), 0, NULL))
return -1; return -1;


index_tree = parse_tree_indirect(&index); index_tree = parse_tree_indirect(&index);

4
builtin/cat-file.c
View File

@ -3,7 +3,7 @@
* *
* Copyright (C) Linus Torvalds, 2005 * Copyright (C) Linus Torvalds, 2005
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "convert.h" #include "convert.h"
@ -77,7 +77,7 @@ static int filter_object(const char *path, unsigned mode,
struct checkout_metadata meta; struct checkout_metadata meta;


init_checkout_metadata(&meta, NULL, NULL, oid); init_checkout_metadata(&meta, NULL, NULL, oid);
if (convert_to_working_tree(&the_index, path, *buf, *size, &strbuf, &meta)) { if (convert_to_working_tree(the_repository->index, path, *buf, *size, &strbuf, &meta)) {
free(*buf); free(*buf);
*size = strbuf.len; *size = strbuf.len;
*buf = strbuf_detach(&strbuf, NULL); *buf = strbuf_detach(&strbuf, NULL);

5
builtin/check-attr.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "attr.h" #include "attr.h"
@ -71,9 +70,9 @@ static void check_attr(const char *prefix, struct attr_check *check,
prefix_path(prefix, prefix ? strlen(prefix) : 0, file); prefix_path(prefix, prefix ? strlen(prefix) : 0, file);


if (collect_all) { if (collect_all) {
git_all_attrs(&the_index, full_path, check); git_all_attrs(the_repository->index, full_path, check);
} else { } else {
git_check_attr(&the_index, full_path, check); git_check_attr(the_repository->index, full_path, check);
} }
output_attr(check, file); output_attr(check, file);



7
builtin/check-ignore.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "dir.h" #include "dir.h"
@ -95,21 +94,21 @@ static int check_ignore(struct dir_struct *dir,
PATHSPEC_KEEP_ORDER, PATHSPEC_KEEP_ORDER,
prefix, argv); prefix, argv);


die_path_inside_submodule(&the_index, &pathspec); die_path_inside_submodule(the_repository->index, &pathspec);


/* /*
* look for pathspecs matching entries in the index, since these * look for pathspecs matching entries in the index, since these
* should not be ignored, in order to be consistent with * should not be ignored, in order to be consistent with
* 'git status', 'git add' etc. * 'git status', 'git add' etc.
*/ */
seen = find_pathspecs_matching_against_index(&pathspec, &the_index, seen = find_pathspecs_matching_against_index(&pathspec, the_repository->index,
PS_HEED_SKIP_WORKTREE); PS_HEED_SKIP_WORKTREE);
for (i = 0; i < pathspec.nr; i++) { for (i = 0; i < pathspec.nr; i++) {
full_path = pathspec.items[i].match; full_path = pathspec.items[i].match;
pattern = NULL; pattern = NULL;
if (!seen[i]) { if (!seen[i]) {
int dtype = DT_UNKNOWN; int dtype = DT_UNKNOWN;
pattern = last_matching_pattern(dir, &the_index, pattern = last_matching_pattern(dir, the_repository->index,
full_path, &dtype); full_path, &dtype);
if (!verbose && pattern && if (!verbose && pattern &&
pattern->flags & PATTERN_FLAG_NEGATIVE) pattern->flags & PATTERN_FLAG_NEGATIVE)

22
builtin/checkout-index.c
View File

@ -4,7 +4,7 @@
* Copyright (C) 2005 Linus Torvalds * Copyright (C) 2005 Linus Torvalds
* *
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "gettext.h" #include "gettext.h"
@ -69,7 +69,7 @@ static void write_tempfile_record(const char *name, const char *prefix)
static int checkout_file(const char *name, const char *prefix) static int checkout_file(const char *name, const char *prefix)
{ {
int namelen = strlen(name); int namelen = strlen(name);
int pos = index_name_pos(&the_index, name, namelen); int pos = index_name_pos(the_repository->index, name, namelen);
int has_same_name = 0; int has_same_name = 0;
int is_file = 0; int is_file = 0;
int is_skipped = 1; int is_skipped = 1;
@ -79,8 +79,8 @@ static int checkout_file(const char *name, const char *prefix)
if (pos < 0) if (pos < 0)
pos = -pos - 1; pos = -pos - 1;


while (pos < the_index.cache_nr) { while (pos <the_repository->index->cache_nr) {
struct cache_entry *ce = the_index.cache[pos]; struct cache_entry *ce =the_repository->index->cache[pos];
if (ce_namelen(ce) != namelen || if (ce_namelen(ce) != namelen ||
memcmp(ce->name, name, namelen)) memcmp(ce->name, name, namelen))
break; break;
@ -140,8 +140,8 @@ static int checkout_all(const char *prefix, int prefix_length)
int i, errs = 0; int i, errs = 0;
struct cache_entry *last_ce = NULL; struct cache_entry *last_ce = NULL;


for (i = 0; i < the_index.cache_nr ; i++) { for (i = 0; i < the_repository->index->cache_nr ; i++) {
struct cache_entry *ce = the_index.cache[i]; struct cache_entry *ce = the_repository->index->cache[i];


if (S_ISSPARSEDIR(ce->ce_mode)) { if (S_ISSPARSEDIR(ce->ce_mode)) {
if (!ce_skip_worktree(ce)) if (!ce_skip_worktree(ce))
@ -154,8 +154,8 @@ static int checkout_all(const char *prefix, int prefix_length)
* first entry inside the expanded sparse directory). * first entry inside the expanded sparse directory).
*/ */
if (ignore_skip_worktree) { if (ignore_skip_worktree) {
ensure_full_index(&the_index); ensure_full_index(the_repository->index);
ce = the_index.cache[i]; ce = the_repository->index->cache[i];
} }
} }


@ -260,7 +260,7 @@ int cmd_checkout_index(int argc, const char **argv, const char *prefix)


argc = parse_options(argc, argv, prefix, builtin_checkout_index_options, argc = parse_options(argc, argv, prefix, builtin_checkout_index_options,
builtin_checkout_index_usage, 0); builtin_checkout_index_usage, 0);
state.istate = &the_index; state.istate = the_repository->index;
state.force = force; state.force = force;
state.quiet = quiet; state.quiet = quiet;
state.not_new = not_new; state.not_new = not_new;
@ -280,7 +280,7 @@ int cmd_checkout_index(int argc, const char **argv, const char *prefix)
*/ */
if (index_opt && !state.base_dir_len && !to_tempfile) { if (index_opt && !state.base_dir_len && !to_tempfile) {
state.refresh_cache = 1; state.refresh_cache = 1;
state.istate = &the_index; state.istate = the_repository->index;
repo_hold_locked_index(the_repository, &lock_file, repo_hold_locked_index(the_repository, &lock_file,
LOCK_DIE_ON_ERROR); LOCK_DIE_ON_ERROR);
} }
@ -339,7 +339,7 @@ int cmd_checkout_index(int argc, const char **argv, const char *prefix)
return 1; return 1;


if (is_lock_file_locked(&lock_file) && if (is_lock_file_locked(&lock_file) &&
write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
die("Unable to write new index file"); die("Unable to write new index file");
return 0; return 0;
} }

87
builtin/checkout.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "advice.h" #include "advice.h"
#include "branch.h" #include "branch.h"
@ -146,7 +145,7 @@ static int update_some(const struct object_id *oid, struct strbuf *base,
return READ_TREE_RECURSIVE; return READ_TREE_RECURSIVE;


len = base->len + strlen(pathname); len = base->len + strlen(pathname);
ce = make_empty_cache_entry(&the_index, len); ce = make_empty_cache_entry(the_repository->index, len);
oidcpy(&ce->oid, oid); oidcpy(&ce->oid, oid);
memcpy(ce->name, base->buf, base->len); memcpy(ce->name, base->buf, base->len);
memcpy(ce->name + base->len, pathname, len - base->len); memcpy(ce->name + base->len, pathname, len - base->len);
@ -159,9 +158,9 @@ static int update_some(const struct object_id *oid, struct strbuf *base,
* entry in place. Whether it is UPTODATE or not, checkout_entry will * entry in place. Whether it is UPTODATE or not, checkout_entry will
* do the right thing. * do the right thing.
*/ */
pos = index_name_pos(&the_index, ce->name, ce->ce_namelen); pos = index_name_pos(the_repository->index, ce->name, ce->ce_namelen);
if (pos >= 0) { if (pos >= 0) {
struct cache_entry *old = the_index.cache[pos]; struct cache_entry *old = the_repository->index->cache[pos];
if (ce->ce_mode == old->ce_mode && if (ce->ce_mode == old->ce_mode &&
!ce_intent_to_add(old) && !ce_intent_to_add(old) &&
oideq(&ce->oid, &old->oid)) { oideq(&ce->oid, &old->oid)) {
@ -171,7 +170,7 @@ static int update_some(const struct object_id *oid, struct strbuf *base,
} }
} }


add_index_entry(&the_index, ce, add_index_entry(the_repository->index, ce,
ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE); ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
return 0; return 0;
} }
@ -190,8 +189,8 @@ static int read_tree_some(struct tree *tree, const struct pathspec *pathspec)


static int skip_same_name(const struct cache_entry *ce, int pos) static int skip_same_name(const struct cache_entry *ce, int pos)
{ {
while (++pos < the_index.cache_nr && while (++pos < the_repository->index->cache_nr &&
!strcmp(the_index.cache[pos]->name, ce->name)) !strcmp(the_repository->index->cache[pos]->name, ce->name))
; /* skip */ ; /* skip */
return pos; return pos;
} }
@ -199,9 +198,9 @@ static int skip_same_name(const struct cache_entry *ce, int pos)
static int check_stage(int stage, const struct cache_entry *ce, int pos, static int check_stage(int stage, const struct cache_entry *ce, int pos,
int overlay_mode) int overlay_mode)
{ {
while (pos < the_index.cache_nr && while (pos < the_repository->index->cache_nr &&
!strcmp(the_index.cache[pos]->name, ce->name)) { !strcmp(the_repository->index->cache[pos]->name, ce->name)) {
if (ce_stage(the_index.cache[pos]) == stage) if (ce_stage(the_repository->index->cache[pos]) == stage)
return 0; return 0;
pos++; pos++;
} }
@ -218,8 +217,8 @@ static int check_stages(unsigned stages, const struct cache_entry *ce, int pos)
unsigned seen = 0; unsigned seen = 0;
const char *name = ce->name; const char *name = ce->name;


while (pos < the_index.cache_nr) { while (pos < the_repository->index->cache_nr) {
ce = the_index.cache[pos]; ce = the_repository->index->cache[pos];
if (strcmp(name, ce->name)) if (strcmp(name, ce->name))
break; break;
seen |= (1 << ce_stage(ce)); seen |= (1 << ce_stage(ce));
@ -235,10 +234,10 @@ static int checkout_stage(int stage, const struct cache_entry *ce, int pos,
const struct checkout *state, int *nr_checkouts, const struct checkout *state, int *nr_checkouts,
int overlay_mode) int overlay_mode)
{ {
while (pos < the_index.cache_nr && while (pos < the_repository->index->cache_nr &&
!strcmp(the_index.cache[pos]->name, ce->name)) { !strcmp(the_repository->index->cache[pos]->name, ce->name)) {
if (ce_stage(the_index.cache[pos]) == stage) if (ce_stage(the_repository->index->cache[pos]) == stage)
return checkout_entry(the_index.cache[pos], state, return checkout_entry(the_repository->index->cache[pos], state,
NULL, nr_checkouts); NULL, nr_checkouts);
pos++; pos++;
} }
@ -256,7 +255,7 @@ static int checkout_merged(int pos, const struct checkout *state,
int *nr_checkouts, struct mem_pool *ce_mem_pool, int *nr_checkouts, struct mem_pool *ce_mem_pool,
int conflict_style) int conflict_style)
{ {
struct cache_entry *ce = the_index.cache[pos]; struct cache_entry *ce = the_repository->index->cache[pos];
const char *path = ce->name; const char *path = ce->name;
mmfile_t ancestor, ours, theirs; mmfile_t ancestor, ours, theirs;
enum ll_merge_result merge_status; enum ll_merge_result merge_status;
@ -269,7 +268,7 @@ static int checkout_merged(int pos, const struct checkout *state,
int renormalize = 0; int renormalize = 0;


memset(threeway, 0, sizeof(threeway)); memset(threeway, 0, sizeof(threeway));
while (pos < the_index.cache_nr) { while (pos < the_repository->index->cache_nr) {
int stage; int stage;
stage = ce_stage(ce); stage = ce_stage(ce);
if (!stage || strcmp(path, ce->name)) if (!stage || strcmp(path, ce->name))
@ -278,7 +277,7 @@ static int checkout_merged(int pos, const struct checkout *state,
if (stage == 2) if (stage == 2)
mode = create_ce_mode(ce->ce_mode); mode = create_ce_mode(ce->ce_mode);
pos++; pos++;
ce = the_index.cache[pos]; ce = the_repository->index->cache[pos];
} }
if (is_null_oid(&threeway[1]) || is_null_oid(&threeway[2])) if (is_null_oid(&threeway[1]) || is_null_oid(&threeway[2]))
return error(_("path '%s' does not have necessary versions"), path); return error(_("path '%s' does not have necessary versions"), path);
@ -356,7 +355,7 @@ static void mark_ce_for_checkout_overlay(struct cache_entry *ce,
* match_pathspec() for _all_ entries when * match_pathspec() for _all_ entries when
* opts->source_tree != NULL. * opts->source_tree != NULL.
*/ */
if (ce_path_match(&the_index, ce, &opts->pathspec, ps_matched)) if (ce_path_match(the_repository->index, ce, &opts->pathspec, ps_matched))
ce->ce_flags |= CE_MATCHED; ce->ce_flags |= CE_MATCHED;
} }


@ -367,7 +366,7 @@ static void mark_ce_for_checkout_no_overlay(struct cache_entry *ce,
ce->ce_flags &= ~CE_MATCHED; ce->ce_flags &= ~CE_MATCHED;
if (!opts->ignore_skipworktree && ce_skip_worktree(ce)) if (!opts->ignore_skipworktree && ce_skip_worktree(ce))
return; return;
if (ce_path_match(&the_index, ce, &opts->pathspec, ps_matched)) { if (ce_path_match(the_repository->index, ce, &opts->pathspec, ps_matched)) {
ce->ce_flags |= CE_MATCHED; ce->ce_flags |= CE_MATCHED;
if (opts->source_tree && !(ce->ce_flags & CE_UPDATE)) if (opts->source_tree && !(ce->ce_flags & CE_UPDATE))
/* /*
@ -391,7 +390,7 @@ static int checkout_worktree(const struct checkout_opts *opts,


state.force = 1; state.force = 1;
state.refresh_cache = 1; state.refresh_cache = 1;
state.istate = &the_index; state.istate = the_repository->index;


mem_pool_init(&ce_mem_pool, 0); mem_pool_init(&ce_mem_pool, 0);
get_parallel_checkout_configs(&pc_workers, &pc_threshold); get_parallel_checkout_configs(&pc_workers, &pc_threshold);
@ -404,8 +403,8 @@ static int checkout_worktree(const struct checkout_opts *opts,
if (pc_workers > 1) if (pc_workers > 1)
init_parallel_checkout(); init_parallel_checkout();


for (pos = 0; pos < the_index.cache_nr; pos++) { for (pos = 0; pos < the_repository->index->cache_nr; pos++) {
struct cache_entry *ce = the_index.cache[pos]; struct cache_entry *ce = the_repository->index->cache[pos];
if (ce->ce_flags & CE_MATCHED) { if (ce->ce_flags & CE_MATCHED) {
if (!ce_stage(ce)) { if (!ce_stage(ce)) {
errs |= checkout_entry(ce, &state, errs |= checkout_entry(ce, &state,
@ -429,7 +428,7 @@ static int checkout_worktree(const struct checkout_opts *opts,
errs |= run_parallel_checkout(&state, pc_workers, pc_threshold, errs |= run_parallel_checkout(&state, pc_workers, pc_threshold,
NULL, NULL); NULL, NULL);
mem_pool_discard(&ce_mem_pool, should_validate_cache_entries()); mem_pool_discard(&ce_mem_pool, should_validate_cache_entries());
remove_marked_cache_entries(&the_index, 1); remove_marked_cache_entries(the_repository->index, 1);
remove_scheduled_dirs(); remove_scheduled_dirs();
errs |= finish_delayed_checkout(&state, opts->show_progress); errs |= finish_delayed_checkout(&state, opts->show_progress);


@ -571,7 +570,7 @@ static int checkout_paths(const struct checkout_opts *opts,
if (opts->source_tree) if (opts->source_tree)
read_tree_some(opts->source_tree, &opts->pathspec); read_tree_some(opts->source_tree, &opts->pathspec);
if (opts->merge) if (opts->merge)
unmerge_index(&the_index, &opts->pathspec, CE_MATCHED); unmerge_index(the_repository->index, &opts->pathspec, CE_MATCHED);


ps_matched = xcalloc(opts->pathspec.nr, 1); ps_matched = xcalloc(opts->pathspec.nr, 1);


@ -579,13 +578,13 @@ static int checkout_paths(const struct checkout_opts *opts,
* Make sure all pathspecs participated in locating the paths * Make sure all pathspecs participated in locating the paths
* to be checked out. * to be checked out.
*/ */
for (pos = 0; pos < the_index.cache_nr; pos++) for (pos = 0; pos < the_repository->index->cache_nr; pos++)
if (opts->overlay_mode) if (opts->overlay_mode)
mark_ce_for_checkout_overlay(the_index.cache[pos], mark_ce_for_checkout_overlay(the_repository->index->cache[pos],
ps_matched, ps_matched,
opts); opts);
else else
mark_ce_for_checkout_no_overlay(the_index.cache[pos], mark_ce_for_checkout_no_overlay(the_repository->index->cache[pos],
ps_matched, ps_matched,
opts); opts);


@ -596,8 +595,8 @@ static int checkout_paths(const struct checkout_opts *opts,
free(ps_matched); free(ps_matched);


/* Any unmerged paths? */ /* Any unmerged paths? */
for (pos = 0; pos < the_index.cache_nr; pos++) { for (pos = 0; pos < the_repository->index->cache_nr; pos++) {
const struct cache_entry *ce = the_index.cache[pos]; const struct cache_entry *ce = the_repository->index->cache[pos];
if (ce->ce_flags & CE_MATCHED) { if (ce->ce_flags & CE_MATCHED) {
if (!ce_stage(ce)) if (!ce_stage(ce))
continue; continue;
@ -622,7 +621,7 @@ static int checkout_paths(const struct checkout_opts *opts,
if (opts->checkout_worktree) if (opts->checkout_worktree)
errs |= checkout_worktree(opts, new_branch_info); errs |= checkout_worktree(opts, new_branch_info);
else else
remove_marked_cache_entries(&the_index, 1); remove_marked_cache_entries(the_repository->index, 1);


/* /*
* Allow updating the index when checking out from the index. * Allow updating the index when checking out from the index.
@ -634,7 +633,7 @@ static int checkout_paths(const struct checkout_opts *opts,
checkout_index = opts->checkout_index; checkout_index = opts->checkout_index;


if (checkout_index) { if (checkout_index) {
if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
die(_("unable to write new index file")); die(_("unable to write new index file"));
} else { } else {
/* /*
@ -703,8 +702,8 @@ static int reset_tree(struct tree *tree, const struct checkout_opts *o,
opts.merge = 1; opts.merge = 1;
opts.fn = oneway_merge; opts.fn = oneway_merge;
opts.verbose_update = o->show_progress; opts.verbose_update = o->show_progress;
opts.src_index = &the_index; opts.src_index = the_repository->index;
opts.dst_index = &the_index; opts.dst_index = the_repository->index;
init_checkout_metadata(&opts.meta, info->refname, init_checkout_metadata(&opts.meta, info->refname,
info->commit ? &info->commit->object.oid : null_oid(), info->commit ? &info->commit->object.oid : null_oid(),
NULL); NULL);
@ -756,12 +755,12 @@ static void init_topts(struct unpack_trees_options *topts, int merge,
{ {
memset(topts, 0, sizeof(*topts)); memset(topts, 0, sizeof(*topts));
topts->head_idx = -1; topts->head_idx = -1;
topts->src_index = &the_index; topts->src_index = the_repository->index;
topts->dst_index = &the_index; topts->dst_index = the_repository->index;


setup_unpack_trees_porcelain(topts, "checkout"); setup_unpack_trees_porcelain(topts, "checkout");


topts->initial_checkout = is_index_unborn(&the_index); topts->initial_checkout = is_index_unborn(the_repository->index);
topts->update = 1; topts->update = 1;
topts->merge = 1; topts->merge = 1;
topts->quiet = merge && old_commit; topts->quiet = merge && old_commit;
@ -783,7 +782,7 @@ static int merge_working_tree(const struct checkout_opts *opts,
if (repo_read_index_preload(the_repository, NULL, 0) < 0) if (repo_read_index_preload(the_repository, NULL, 0) < 0)
return error(_("index file corrupt")); return error(_("index file corrupt"));


resolve_undo_clear_index(&the_index); resolve_undo_clear_index(the_repository->index);
if (opts->new_orphan_branch && opts->orphan_from_empty_tree) { if (opts->new_orphan_branch && opts->orphan_from_empty_tree) {
if (new_branch_info->commit) if (new_branch_info->commit)
BUG("'switch --orphan' should never accept a commit as starting point"); BUG("'switch --orphan' should never accept a commit as starting point");
@ -807,9 +806,9 @@ static int merge_working_tree(const struct checkout_opts *opts,
struct unpack_trees_options topts; struct unpack_trees_options topts;
const struct object_id *old_commit_oid; const struct object_id *old_commit_oid;


refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL); refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL);


if (unmerged_index(&the_index)) { if (unmerged_index(the_repository->index)) {
error(_("you need to resolve your current index first")); error(_("you need to resolve your current index first"));
return 1; return 1;
} }
@ -919,10 +918,10 @@ static int merge_working_tree(const struct checkout_opts *opts,
} }
} }


if (!cache_tree_fully_valid(the_index.cache_tree)) if (!cache_tree_fully_valid(the_repository->index->cache_tree))
cache_tree_update(&the_index, WRITE_TREE_SILENT | WRITE_TREE_REPAIR); cache_tree_update(the_repository->index, WRITE_TREE_SILENT | WRITE_TREE_REPAIR);


if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
die(_("unable to write new index file")); die(_("unable to write new index file"));


if (!opts->discard_changes && !opts->quiet && new_branch_info->commit) if (!opts->discard_changes && !opts->quiet && new_branch_info->commit)

7
builtin/clean.c
View File

@ -6,7 +6,6 @@
* Based on git-clean.sh by Pavel Roskin * Based on git-clean.sh by Pavel Roskin
*/ */


#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "config.h" #include "config.h"
@ -714,7 +713,7 @@ static int filter_by_patterns_cmd(void)
for_each_string_list_item(item, &del_list) { for_each_string_list_item(item, &del_list) {
int dtype = DT_UNKNOWN; int dtype = DT_UNKNOWN;


if (is_excluded(&dir, &the_index, item->string, &dtype)) { if (is_excluded(&dir, the_repository->index, item->string, &dtype)) {
*item->string = '\0'; *item->string = '\0';
changed++; changed++;
} }
@ -1021,7 +1020,7 @@ int cmd_clean(int argc, const char **argv, const char *prefix)
PATHSPEC_PREFER_CWD, PATHSPEC_PREFER_CWD,
prefix, argv); prefix, argv);


fill_directory(&dir, &the_index, &pathspec); fill_directory(&dir, the_repository->index, &pathspec);
correct_untracked_entries(&dir); correct_untracked_entries(&dir);


for (i = 0; i < dir.nr; i++) { for (i = 0; i < dir.nr; i++) {
@ -1029,7 +1028,7 @@ int cmd_clean(int argc, const char **argv, const char *prefix)
struct stat st; struct stat st;
const char *rel; const char *rel;


if (!index_name_is_other(&the_index, ent->name, ent->len)) if (!index_name_is_other(the_repository->index, ent->name, ent->len))
continue; continue;


if (lstat(ent->name, &st)) if (lstat(ent->name, &st))

81
builtin/commit.c
View File

@ -5,7 +5,6 @@
* Based on git-commit.sh by Junio C Hamano and Linus Torvalds * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
*/ */


#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "advice.h" #include "advice.h"
#include "config.h" #include "config.h"
@ -266,19 +265,19 @@ static int list_paths(struct string_list *list, const char *with_tree,


if (with_tree) { if (with_tree) {
char *max_prefix = common_prefix(pattern); char *max_prefix = common_prefix(pattern);
overlay_tree_on_index(&the_index, with_tree, max_prefix); overlay_tree_on_index(the_repository->index, with_tree, max_prefix);
free(max_prefix); free(max_prefix);
} }


/* TODO: audit for interaction with sparse-index. */ /* TODO: audit for interaction with sparse-index. */
ensure_full_index(&the_index); ensure_full_index(the_repository->index);
for (i = 0; i < the_index.cache_nr; i++) { for (i = 0; i < the_repository->index->cache_nr; i++) {
const struct cache_entry *ce = the_index.cache[i]; const struct cache_entry *ce = the_repository->index->cache[i];
struct string_list_item *item; struct string_list_item *item;


if (ce->ce_flags & CE_UPDATE) if (ce->ce_flags & CE_UPDATE)
continue; continue;
if (!ce_path_match(&the_index, ce, pattern, m)) if (!ce_path_match(the_repository->index, ce, pattern, m))
continue; continue;
item = string_list_insert(list, ce->name); item = string_list_insert(list, ce->name);
if (ce_skip_worktree(ce)) if (ce_skip_worktree(ce))
@ -302,10 +301,10 @@ static void add_remove_files(struct string_list *list)
continue; continue;


if (!lstat(p->string, &st)) { if (!lstat(p->string, &st)) {
if (add_to_index(&the_index, p->string, &st, 0)) if (add_to_index(the_repository->index, p->string, &st, 0))
die(_("updating files failed")); die(_("updating files failed"));
} else } else
remove_file_from_index(&the_index, p->string); remove_file_from_index(the_repository->index, p->string);
} }
} }


@ -316,7 +315,7 @@ static void create_base_index(const struct commit *current_head)
struct tree_desc t; struct tree_desc t;


if (!current_head) { if (!current_head) {
discard_index(&the_index); discard_index(the_repository->index);
return; return;
} }


@ -324,8 +323,8 @@ static void create_base_index(const struct commit *current_head)
opts.head_idx = 1; opts.head_idx = 1;
opts.index_only = 1; opts.index_only = 1;
opts.merge = 1; opts.merge = 1;
opts.src_index = &the_index; opts.src_index = the_repository->index;
opts.dst_index = &the_index; opts.dst_index = the_repository->index;


opts.fn = oneway_merge; opts.fn = oneway_merge;
tree = parse_tree_indirect(&current_head->object.oid); tree = parse_tree_indirect(&current_head->object.oid);
@ -344,7 +343,7 @@ static void refresh_cache_or_die(int refresh_flags)
* refresh_flags contains REFRESH_QUIET, so the only errors * refresh_flags contains REFRESH_QUIET, so the only errors
* are for unmerged entries. * are for unmerged entries.
*/ */
if (refresh_index(&the_index, refresh_flags | REFRESH_IN_PORCELAIN, NULL, NULL, NULL)) if (refresh_index(the_repository->index, refresh_flags | REFRESH_IN_PORCELAIN, NULL, NULL, NULL))
die_resolve_conflict("commit"); die_resolve_conflict("commit");
} }


@ -393,7 +392,7 @@ static const char *prepare_index(const char **argv, const char *prefix,


refresh_cache_or_die(refresh_flags); refresh_cache_or_die(refresh_flags);


if (write_locked_index(&the_index, &index_lock, 0)) if (write_locked_index(the_repository->index, &index_lock, 0))
die(_("unable to create temporary index")); die(_("unable to create temporary index"));


old_repo_index_file = the_repository->index_file; old_repo_index_file = the_repository->index_file;
@ -412,13 +411,13 @@ static const char *prepare_index(const char **argv, const char *prefix,
unsetenv(INDEX_ENVIRONMENT); unsetenv(INDEX_ENVIRONMENT);
FREE_AND_NULL(old_index_env); FREE_AND_NULL(old_index_env);


discard_index(&the_index); discard_index(the_repository->index);
read_index_from(&the_index, get_lock_file_path(&index_lock), read_index_from(the_repository->index, get_lock_file_path(&index_lock),
get_git_dir()); get_git_dir());
if (cache_tree_update(&the_index, WRITE_TREE_SILENT) == 0) { if (cache_tree_update(the_repository->index, WRITE_TREE_SILENT) == 0) {
if (reopen_lock_file(&index_lock) < 0) if (reopen_lock_file(&index_lock) < 0)
die(_("unable to write index file")); die(_("unable to write index file"));
if (write_locked_index(&the_index, &index_lock, 0)) if (write_locked_index(the_repository->index, &index_lock, 0))
die(_("unable to update temporary index")); die(_("unable to update temporary index"));
} else } else
warning(_("Failed to update main cache tree")); warning(_("Failed to update main cache tree"));
@ -450,8 +449,8 @@ static const char *prepare_index(const char **argv, const char *prefix,
exit(128); exit(128);


refresh_cache_or_die(refresh_flags); refresh_cache_or_die(refresh_flags);
cache_tree_update(&the_index, WRITE_TREE_SILENT); cache_tree_update(the_repository->index, WRITE_TREE_SILENT);
if (write_locked_index(&the_index, &index_lock, 0)) if (write_locked_index(the_repository->index, &index_lock, 0))
die(_("unable to write new index file")); die(_("unable to write new index file"));
commit_style = COMMIT_NORMAL; commit_style = COMMIT_NORMAL;
ret = get_lock_file_path(&index_lock); ret = get_lock_file_path(&index_lock);
@ -472,10 +471,10 @@ static const char *prepare_index(const char **argv, const char *prefix,
repo_hold_locked_index(the_repository, &index_lock, repo_hold_locked_index(the_repository, &index_lock,
LOCK_DIE_ON_ERROR); LOCK_DIE_ON_ERROR);
refresh_cache_or_die(refresh_flags); refresh_cache_or_die(refresh_flags);
if (the_index.cache_changed if (the_repository->index->cache_changed
|| !cache_tree_fully_valid(the_index.cache_tree)) || !cache_tree_fully_valid(the_repository->index->cache_tree))
cache_tree_update(&the_index, WRITE_TREE_SILENT); cache_tree_update(the_repository->index, WRITE_TREE_SILENT);
if (write_locked_index(&the_index, &index_lock, if (write_locked_index(the_repository->index, &index_lock,
COMMIT_LOCK | SKIP_IF_UNCHANGED)) COMMIT_LOCK | SKIP_IF_UNCHANGED))
die(_("unable to write new index file")); die(_("unable to write new index file"));
commit_style = COMMIT_AS_IS; commit_style = COMMIT_AS_IS;
@ -516,15 +515,15 @@ static const char *prepare_index(const char **argv, const char *prefix,
if (list_paths(&partial, !current_head ? NULL : "HEAD", &pathspec)) if (list_paths(&partial, !current_head ? NULL : "HEAD", &pathspec))
exit(1); exit(1);


discard_index(&the_index); discard_index(the_repository->index);
if (repo_read_index(the_repository) < 0) if (repo_read_index(the_repository) < 0)
die(_("cannot read the index")); die(_("cannot read the index"));


repo_hold_locked_index(the_repository, &index_lock, LOCK_DIE_ON_ERROR); repo_hold_locked_index(the_repository, &index_lock, LOCK_DIE_ON_ERROR);
add_remove_files(&partial); add_remove_files(&partial);
refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL); refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL);
cache_tree_update(&the_index, WRITE_TREE_SILENT); cache_tree_update(the_repository->index, WRITE_TREE_SILENT);
if (write_locked_index(&the_index, &index_lock, 0)) if (write_locked_index(the_repository->index, &index_lock, 0))
die(_("unable to write new index file")); die(_("unable to write new index file"));


hold_lock_file_for_update(&false_lock, hold_lock_file_for_update(&false_lock,
@ -534,14 +533,14 @@ static const char *prepare_index(const char **argv, const char *prefix,


create_base_index(current_head); create_base_index(current_head);
add_remove_files(&partial); add_remove_files(&partial);
refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL); refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL);


if (write_locked_index(&the_index, &false_lock, 0)) if (write_locked_index(the_repository->index, &false_lock, 0))
die(_("unable to write temporary index file")); die(_("unable to write temporary index file"));


discard_index(&the_index); discard_index(the_repository->index);
ret = get_lock_file_path(&false_lock); ret = get_lock_file_path(&false_lock);
read_index_from(&the_index, ret, get_git_dir()); read_index_from(the_repository->index, ret, get_git_dir());
out: out:
string_list_clear(&partial, 0); string_list_clear(&partial, 0);
clear_pathspec(&pathspec); clear_pathspec(&pathspec);
@ -999,7 +998,7 @@ static int prepare_to_commit(const char *index_file, const char *prefix,
struct object_id oid; struct object_id oid;
const char *parent = "HEAD"; const char *parent = "HEAD";


if (!the_index.initialized && repo_read_index(the_repository) < 0) if (!the_repository->index->initialized && repo_read_index(the_repository) < 0)
die(_("Cannot read index")); die(_("Cannot read index"));


if (amend) if (amend)
@ -1009,11 +1008,11 @@ static int prepare_to_commit(const char *index_file, const char *prefix,
int i, ita_nr = 0; int i, ita_nr = 0;


/* TODO: audit for interaction with sparse-index. */ /* TODO: audit for interaction with sparse-index. */
ensure_full_index(&the_index); ensure_full_index(the_repository->index);
for (i = 0; i < the_index.cache_nr; i++) for (i = 0; i < the_repository->index->cache_nr; i++)
if (ce_intent_to_add(the_index.cache[i])) if (ce_intent_to_add(the_repository->index->cache[i]))
ita_nr++; ita_nr++;
committable = the_index.cache_nr - ita_nr > 0; committable = the_repository->index->cache_nr - ita_nr > 0;
} else { } else {
/* /*
* Unless the user did explicitly request a submodule * Unless the user did explicitly request a submodule
@ -1081,11 +1080,11 @@ static int prepare_to_commit(const char *index_file, const char *prefix,
* and could have updated it. We must do this before we invoke * and could have updated it. We must do this before we invoke
* the editor and after we invoke run_status above. * the editor and after we invoke run_status above.
*/ */
discard_index(&the_index); discard_index(the_repository->index);
} }
read_index_from(&the_index, index_file, get_git_dir()); read_index_from(the_repository->index, index_file, get_git_dir());


if (cache_tree_update(&the_index, 0)) { if (cache_tree_update(the_repository->index, 0)) {
error(_("Error building trees")); error(_("Error building trees"));
return 0; return 0;
} }
@ -1586,7 +1585,7 @@ int cmd_status(int argc, const char **argv, const char *prefix)
status_format != STATUS_FORMAT_PORCELAIN_V2) status_format != STATUS_FORMAT_PORCELAIN_V2)
progress_flag = REFRESH_PROGRESS; progress_flag = REFRESH_PROGRESS;
repo_read_index(the_repository); repo_read_index(the_repository);
refresh_index(&the_index, refresh_index(the_repository->index,
REFRESH_QUIET|REFRESH_UNMERGED|progress_flag, REFRESH_QUIET|REFRESH_UNMERGED|progress_flag,
&s.pathspec, NULL, NULL); &s.pathspec, NULL, NULL);


@ -1856,7 +1855,7 @@ int cmd_commit(int argc, const char **argv, const char *prefix)
append_merge_tag_headers(parents, &tail); append_merge_tag_headers(parents, &tail);
} }


if (commit_tree_extended(sb.buf, sb.len, &the_index.cache_tree->oid, if (commit_tree_extended(sb.buf, sb.len, &the_repository->index->cache_tree->oid,
parents, &oid, author_ident.buf, NULL, parents, &oid, author_ident.buf, NULL,
sign_commit, extra)) { sign_commit, extra)) {
rollback_index_files(); rollback_index_files();

3
builtin/describe.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "environment.h" #include "environment.h"
@ -674,7 +673,7 @@ int cmd_describe(int argc, const char **argv, const char *prefix)
prepare_repo_settings(the_repository); prepare_repo_settings(the_repository);
the_repository->settings.command_requires_full_index = 0; the_repository->settings.command_requires_full_index = 0;
repo_read_index(the_repository); repo_read_index(the_repository);
refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, refresh_index(the_repository->index, REFRESH_QUIET|REFRESH_UNMERGED,
NULL, NULL, NULL); NULL, NULL, NULL);
fd = repo_hold_locked_index(the_repository, fd = repo_hold_locked_index(the_repository,
&index_lock, 0); &index_lock, 0);

3
builtin/diff-tree.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "diff.h" #include "diff.h"
@ -206,7 +205,7 @@ int cmd_diff_tree(int argc, const char **argv, const char *prefix)
opt->diffopt.rotate_to_strict = 0; opt->diffopt.rotate_to_strict = 0;
opt->diffopt.no_free = 1; opt->diffopt.no_free = 1;
if (opt->diffopt.detect_rename) { if (opt->diffopt.detect_rename) {
if (!the_index.cache) if (the_repository->index->cache)
repo_read_index(the_repository); repo_read_index(the_repository);
opt->diffopt.setup |= DIFF_SETUP_USE_SIZE_CACHE; opt->diffopt.setup |= DIFF_SETUP_USE_SIZE_CACHE;
} }

6
builtin/diff.c
View File

@ -3,7 +3,7 @@
* *
* Copyright (c) 2006 Junio C Hamano * Copyright (c) 2006 Junio C Hamano
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "ewah/ewok.h" #include "ewah/ewok.h"
@ -239,9 +239,9 @@ static void refresh_index_quietly(void)
fd = repo_hold_locked_index(the_repository, &lock_file, 0); fd = repo_hold_locked_index(the_repository, &lock_file, 0);
if (fd < 0) if (fd < 0)
return; return;
discard_index(&the_index); discard_index(the_repository->index);
repo_read_index(the_repository); repo_read_index(the_repository);
refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, refresh_index(the_repository->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL,
NULL); NULL);
repo_update_index_if_able(the_repository, &lock_file); repo_update_index_if_able(the_repository, &lock_file);
} }

4
builtin/difftool.c
View File

@ -11,7 +11,7 @@
* *
* Copyright (C) 2016 Johannes Schindelin * Copyright (C) 2016 Johannes Schindelin
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "config.h" #include "config.h"
@ -117,7 +117,7 @@ static int use_wt_file(const char *workdir, const char *name,
int fd = open(buf.buf, O_RDONLY); int fd = open(buf.buf, O_RDONLY);


if (fd >= 0 && if (fd >= 0 &&
!index_fd(&the_index, &wt_oid, fd, &st, OBJ_BLOB, name, 0)) { !index_fd(the_repository->index, &wt_oid, fd, &st, OBJ_BLOB, name, 0)) {
if (is_null_oid(oid)) { if (is_null_oid(oid)) {
oidcpy(oid, &wt_oid); oidcpy(oid, &wt_oid);
use = 1; use = 1;

17
builtin/merge-index.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "hex.h" #include "hex.h"
#include "read-cache-ll.h" #include "read-cache-ll.h"
@ -18,11 +17,11 @@ static int merge_entry(int pos, const char *path)
char ownbuf[4][60]; char ownbuf[4][60];
struct child_process cmd = CHILD_PROCESS_INIT; struct child_process cmd = CHILD_PROCESS_INIT;


if (pos >= the_index.cache_nr) if (pos >= the_repository->index->cache_nr)
die("git merge-index: %s not in the cache", path); die("git merge-index: %s not in the cache", path);
found = 0; found = 0;
do { do {
const struct cache_entry *ce = the_index.cache[pos]; const struct cache_entry *ce = the_repository->index->cache[pos];
int stage = ce_stage(ce); int stage = ce_stage(ce);


if (strcmp(ce->name, path)) if (strcmp(ce->name, path))
@ -32,7 +31,7 @@ static int merge_entry(int pos, const char *path)
xsnprintf(ownbuf[stage], sizeof(ownbuf[stage]), "%o", ce->ce_mode); xsnprintf(ownbuf[stage], sizeof(ownbuf[stage]), "%o", ce->ce_mode);
arguments[stage] = hexbuf[stage]; arguments[stage] = hexbuf[stage];
arguments[stage + 4] = ownbuf[stage]; arguments[stage + 4] = ownbuf[stage];
} while (++pos < the_index.cache_nr); } while (++pos < the_repository->index->cache_nr);
if (!found) if (!found)
die("git merge-index: %s not in the cache", path); die("git merge-index: %s not in the cache", path);


@ -51,7 +50,7 @@ static int merge_entry(int pos, const char *path)


static void merge_one_path(const char *path) static void merge_one_path(const char *path)
{ {
int pos = index_name_pos(&the_index, path, strlen(path)); int pos = index_name_pos(the_repository->index, path, strlen(path));


/* /*
* If it already exists in the cache as stage0, it's * If it already exists in the cache as stage0, it's
@ -65,9 +64,9 @@ static void merge_all(void)
{ {
int i; int i;
/* TODO: audit for interaction with sparse-index. */ /* TODO: audit for interaction with sparse-index. */
ensure_full_index(&the_index); ensure_full_index(the_repository->index);
for (i = 0; i < the_index.cache_nr; i++) { for (i = 0; i < the_repository->index->cache_nr; i++) {
const struct cache_entry *ce = the_index.cache[i]; const struct cache_entry *ce = the_repository->index->cache[i];
if (!ce_stage(ce)) if (!ce_stage(ce))
continue; continue;
i += merge_entry(i, ce->name)-1; i += merge_entry(i, ce->name)-1;
@ -89,7 +88,7 @@ int cmd_merge_index(int argc, const char **argv, const char *prefix UNUSED)
repo_read_index(the_repository); repo_read_index(the_repository);


/* TODO: audit for interaction with sparse-index. */ /* TODO: audit for interaction with sparse-index. */
ensure_full_index(&the_index); ensure_full_index(the_repository->index);


i = 1; i = 1;
if (!strcmp(argv[i], "-o")) { if (!strcmp(argv[i], "-o")) {

3
builtin/merge-tree.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "tree-walk.h" #include "tree-walk.h"
#include "xdiff-interface.h" #include "xdiff-interface.h"
@ -364,7 +363,7 @@ static void trivial_merge_trees(struct tree_desc t[3], const char *base)


setup_traverse_info(&info, base); setup_traverse_info(&info, base);
info.fn = threeway_callback; info.fn = threeway_callback;
traverse_trees(&the_index, 3, t, &info); traverse_trees(the_repository->index, 3, t, &info);
} }


static void *get_tree_descriptor(struct repository *r, static void *get_tree_descriptor(struct repository *r,

31
builtin/merge.c
View File

@ -6,7 +6,6 @@
* Based on git-merge.sh by Junio C Hamano. * Based on git-merge.sh by Junio C Hamano.
*/ */


#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "advice.h" #include "advice.h"
@ -300,7 +299,7 @@ static int save_state(struct object_id *stash)
int rc = -1; int rc = -1;


fd = repo_hold_locked_index(the_repository, &lock_file, 0); fd = repo_hold_locked_index(the_repository, &lock_file, 0);
refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL); refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL);
if (0 <= fd) if (0 <= fd)
repo_update_index_if_able(the_repository, &lock_file); repo_update_index_if_able(the_repository, &lock_file);
rollback_lock_file(&lock_file); rollback_lock_file(&lock_file);
@ -372,7 +371,7 @@ static void restore_state(const struct object_id *head,
run_command(&cmd); run_command(&cmd);


refresh_cache: refresh_cache:
discard_index(&the_index); discard_index(the_repository->index);
if (repo_read_index(the_repository) < 0) if (repo_read_index(the_repository) < 0)
die(_("could not read index")); die(_("could not read index"));
} }
@ -657,8 +656,8 @@ static int read_tree_trivial(struct object_id *common, struct object_id *head,


memset(&opts, 0, sizeof(opts)); memset(&opts, 0, sizeof(opts));
opts.head_idx = 2; opts.head_idx = 2;
opts.src_index = &the_index; opts.src_index = the_repository->index;
opts.dst_index = &the_index; opts.dst_index = the_repository->index;
opts.update = 1; opts.update = 1;
opts.verbose_update = 1; opts.verbose_update = 1;
opts.trivial_merges_only = 1; opts.trivial_merges_only = 1;
@ -674,7 +673,7 @@ static int read_tree_trivial(struct object_id *common, struct object_id *head,
if (!trees[nr_trees++]) if (!trees[nr_trees++])
return -1; return -1;
opts.fn = threeway_merge; opts.fn = threeway_merge;
cache_tree_free(&the_index.cache_tree); cache_tree_free(&the_repository->index->cache_tree);
for (i = 0; i < nr_trees; i++) { for (i = 0; i < nr_trees; i++) {
parse_tree(trees[i]); parse_tree(trees[i]);
init_tree_desc(t+i, &trees[i]->object.oid, init_tree_desc(t+i, &trees[i]->object.oid,
@ -687,7 +686,7 @@ static int read_tree_trivial(struct object_id *common, struct object_id *head,


static void write_tree_trivial(struct object_id *oid) static void write_tree_trivial(struct object_id *oid)
{ {
if (write_index_as_tree(oid, &the_index, get_index_file(), 0, NULL)) if (write_index_as_tree(oid, the_repository->index, get_index_file(), 0, NULL))
die(_("git write-tree failed to write a tree")); die(_("git write-tree failed to write a tree"));
} }


@ -745,7 +744,7 @@ static int try_merge_strategy(const char *strategy, struct commit_list *common,
rollback_lock_file(&lock); rollback_lock_file(&lock);
return 2; return 2;
} }
if (write_locked_index(&the_index, &lock, if (write_locked_index(the_repository->index, &lock,
COMMIT_LOCK | SKIP_IF_UNCHANGED)) COMMIT_LOCK | SKIP_IF_UNCHANGED))
die(_("unable to write %s"), get_index_file()); die(_("unable to write %s"), get_index_file());
return clean ? 0 : 1; return clean ? 0 : 1;
@ -768,8 +767,8 @@ static int count_unmerged_entries(void)
{ {
int i, ret = 0; int i, ret = 0;


for (i = 0; i < the_index.cache_nr; i++) for (i = 0; i < the_repository->index->cache_nr; i++)
if (ce_stage(the_index.cache[i])) if (ce_stage(the_repository->index->cache[i]))
ret++; ret++;


return ret; return ret;
@ -843,9 +842,9 @@ static void prepare_to_commit(struct commit_list *remoteheads)
* the editor and after we invoke run_status above. * the editor and after we invoke run_status above.
*/ */
if (invoked_hook) if (invoked_hook)
discard_index(&the_index); discard_index(the_repository->index);
} }
read_index_from(&the_index, index_file, get_git_dir()); read_index_from(the_repository->index, index_file, get_git_dir());
strbuf_addbuf(&msg, &merge_msg); strbuf_addbuf(&msg, &merge_msg);
if (squash) if (squash)
BUG("the control must not reach here under --squash"); BUG("the control must not reach here under --squash");
@ -957,7 +956,7 @@ static int suggest_conflicts(void)
* Thus, we will get the cleanup mode which is returned when we _are_ * Thus, we will get the cleanup mode which is returned when we _are_
* using an editor. * using an editor.
*/ */
append_conflicts_hint(&the_index, &msgbuf, append_conflicts_hint(the_repository->index, &msgbuf,
get_cleanup_mode(cleanup_arg, 1)); get_cleanup_mode(cleanup_arg, 1));
fputs(msgbuf.buf, fp); fputs(msgbuf.buf, fp);
strbuf_release(&msgbuf); strbuf_release(&msgbuf);
@ -1386,7 +1385,7 @@ int cmd_merge(int argc, const char **argv, const char *prefix)
else else
die(_("You have not concluded your cherry-pick (CHERRY_PICK_HEAD exists).")); die(_("You have not concluded your cherry-pick (CHERRY_PICK_HEAD exists)."));
} }
resolve_undo_clear_index(&the_index); resolve_undo_clear_index(the_repository->index);


if (option_edit < 0) if (option_edit < 0)
option_edit = default_edit_option(); option_edit = default_edit_option();
@ -1595,7 +1594,7 @@ int cmd_merge(int argc, const char **argv, const char *prefix)
* We are not doing octopus, not fast-forward, and have * We are not doing octopus, not fast-forward, and have
* only one common. * only one common.
*/ */
refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL); refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL);
if (allow_trivial && fast_forward != FF_ONLY) { if (allow_trivial && fast_forward != FF_ONLY) {
/* /*
* Must first ensure that index matches HEAD before * Must first ensure that index matches HEAD before
@ -1784,6 +1783,6 @@ done:
} }
strbuf_release(&buf); strbuf_release(&buf);
free(branch_to_free); free(branch_to_free);
discard_index(&the_index); discard_index(the_repository->index);
return ret; return ret;
} }

68
builtin/mv.c
View File

@ -3,7 +3,7 @@
* *
* Copyright (C) 2006 Johannes Schindelin * Copyright (C) 2006 Johannes Schindelin
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "advice.h" #include "advice.h"
@ -95,9 +95,9 @@ static void prepare_move_submodule(const char *src, int first,
const char **submodule_gitfile) const char **submodule_gitfile)
{ {
struct strbuf submodule_dotgit = STRBUF_INIT; struct strbuf submodule_dotgit = STRBUF_INIT;
if (!S_ISGITLINK(the_index.cache[first]->ce_mode)) if (!S_ISGITLINK(the_repository->index->cache[first]->ce_mode))
die(_("Directory %s is in index and no submodule?"), src); die(_("Directory %s is in index and no submodule?"), src);
if (!is_staging_gitmodules_ok(&the_index)) if (!is_staging_gitmodules_ok(the_repository->index))
die(_("Please stage your changes to .gitmodules or stash them to proceed")); die(_("Please stage your changes to .gitmodules or stash them to proceed"));
strbuf_addf(&submodule_dotgit, "%s/.git", src); strbuf_addf(&submodule_dotgit, "%s/.git", src);
*submodule_gitfile = read_gitfile(submodule_dotgit.buf); *submodule_gitfile = read_gitfile(submodule_dotgit.buf);
@ -114,13 +114,13 @@ static int index_range_of_same_dir(const char *src, int length,
const char *src_w_slash = add_slash(src); const char *src_w_slash = add_slash(src);
int first, last, len_w_slash = length + 1; int first, last, len_w_slash = length + 1;


first = index_name_pos(&the_index, src_w_slash, len_w_slash); first = index_name_pos(the_repository->index, src_w_slash, len_w_slash);
if (first >= 0) if (first >= 0)
die(_("%.*s is in index"), len_w_slash, src_w_slash); die(_("%.*s is in index"), len_w_slash, src_w_slash);


first = -1 - first; first = -1 - first;
for (last = first; last < the_index.cache_nr; last++) { for (last = first; last < the_repository->index->cache_nr; last++) {
const char *path = the_index.cache[last]->name; const char *path = the_repository->index->cache[last]->name;
if (strncmp(path, src_w_slash, len_w_slash)) if (strncmp(path, src_w_slash, len_w_slash))
break; break;
} }
@ -144,14 +144,14 @@ static int empty_dir_has_sparse_contents(const char *name)
const char *with_slash = add_slash(name); const char *with_slash = add_slash(name);
int length = strlen(with_slash); int length = strlen(with_slash);


int pos = index_name_pos(&the_index, with_slash, length); int pos = index_name_pos(the_repository->index, with_slash, length);
const struct cache_entry *ce; const struct cache_entry *ce;


if (pos < 0) { if (pos < 0) {
pos = -pos - 1; pos = -pos - 1;
if (pos >= the_index.cache_nr) if (pos >= the_repository->index->cache_nr)
goto free_return; goto free_return;
ce = the_index.cache[pos]; ce = the_repository->index->cache[pos];
if (strncmp(with_slash, ce->name, length)) if (strncmp(with_slash, ce->name, length))
goto free_return; goto free_return;
if (ce_skip_worktree(ce)) if (ce_skip_worktree(ce))
@ -223,7 +223,7 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
S_ISDIR(st.st_mode)) { S_ISDIR(st.st_mode)) {
destination = internal_prefix_pathspec(dst_w_slash, argv, argc, DUP_BASENAME); destination = internal_prefix_pathspec(dst_w_slash, argv, argc, DUP_BASENAME);
} else { } else {
if (!path_in_sparse_checkout(dst_w_slash, &the_index) && if (!path_in_sparse_checkout(dst_w_slash, the_repository->index) &&
empty_dir_has_sparse_contents(dst_w_slash)) { empty_dir_has_sparse_contents(dst_w_slash)) {
destination = internal_prefix_pathspec(dst_w_slash, argv, argc, DUP_BASENAME); destination = internal_prefix_pathspec(dst_w_slash, argv, argc, DUP_BASENAME);
dst_mode = SKIP_WORKTREE_DIR; dst_mode = SKIP_WORKTREE_DIR;
@ -239,7 +239,7 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
* is deprecated at this point) sparse-checkout. As * is deprecated at this point) sparse-checkout. As
* SPARSE here is only considering cone-mode situation. * SPARSE here is only considering cone-mode situation.
*/ */
if (!path_in_cone_mode_sparse_checkout(destination[0], &the_index)) if (!path_in_cone_mode_sparse_checkout(destination[0], the_repository->index))
dst_mode = SPARSE; dst_mode = SPARSE;
} }
} }
@ -263,10 +263,10 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
int pos; int pos;
const struct cache_entry *ce; const struct cache_entry *ce;


pos = index_name_pos(&the_index, src, length); pos = index_name_pos(the_repository->index, src, length);
if (pos < 0) { if (pos < 0) {
const char *src_w_slash = add_slash(src); const char *src_w_slash = add_slash(src);
if (!path_in_sparse_checkout(src_w_slash, &the_index) && if (!path_in_sparse_checkout(src_w_slash, the_repository->index) &&
empty_dir_has_sparse_contents(src)) { empty_dir_has_sparse_contents(src)) {
modes[i] |= SKIP_WORKTREE_DIR; modes[i] |= SKIP_WORKTREE_DIR;
goto dir_check; goto dir_check;
@ -276,7 +276,7 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
bad = _("bad source"); bad = _("bad source");
goto act_on_entry; goto act_on_entry;
} }
ce = the_index.cache[pos]; ce = the_repository->index->cache[pos];
if (!ce_skip_worktree(ce)) { if (!ce_skip_worktree(ce)) {
bad = _("bad source"); bad = _("bad source");
goto act_on_entry; goto act_on_entry;
@ -286,7 +286,7 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
goto act_on_entry; goto act_on_entry;
} }
/* Check if dst exists in index */ /* Check if dst exists in index */
if (index_name_pos(&the_index, dst, strlen(dst)) < 0) { if (index_name_pos(the_repository->index, dst, strlen(dst)) < 0) {
modes[i] |= SPARSE; modes[i] |= SPARSE;
goto act_on_entry; goto act_on_entry;
} }
@ -311,7 +311,7 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
dir_check: dir_check:
if (S_ISDIR(st.st_mode)) { if (S_ISDIR(st.st_mode)) {
int j, dst_len, n; int j, dst_len, n;
int first = index_name_pos(&the_index, src, length), last; int first = index_name_pos(the_repository->index, src, length), last;


if (first >= 0) { if (first >= 0) {
prepare_move_submodule(src, first, prepare_move_submodule(src, first,
@ -339,7 +339,7 @@ dir_check:
dst_len = strlen(dst); dst_len = strlen(dst);


for (j = 0; j < last - first; j++) { for (j = 0; j < last - first; j++) {
const struct cache_entry *ce = the_index.cache[first + j]; const struct cache_entry *ce = the_repository->index->cache[first + j];
const char *path = ce->name; const char *path = ce->name;
source[argc + j] = path; source[argc + j] = path;
destination[argc + j] = destination[argc + j] =
@ -351,7 +351,7 @@ dir_check:
argc += last - first; argc += last - first;
goto act_on_entry; goto act_on_entry;
} }
if (!(ce = index_file_exists(&the_index, src, length, 0))) { if (!(ce = index_file_exists(the_repository->index, src, length, 0))) {
bad = _("not under version control"); bad = _("not under version control");
goto act_on_entry; goto act_on_entry;
} }
@ -387,7 +387,7 @@ dir_check:


if (ignore_sparse && if (ignore_sparse &&
(dst_mode & (SKIP_WORKTREE_DIR | SPARSE)) && (dst_mode & (SKIP_WORKTREE_DIR | SPARSE)) &&
index_entry_exists(&the_index, dst, strlen(dst))) { index_entry_exists(the_repository->index, dst, strlen(dst))) {
bad = _("destination exists in the index"); bad = _("destination exists in the index");
if (force) { if (force) {
if (verbose) if (verbose)
@ -404,12 +404,12 @@ dir_check:
* option as a way to have a successful run. * option as a way to have a successful run.
*/ */
if (!ignore_sparse && if (!ignore_sparse &&
!path_in_sparse_checkout(src, &the_index)) { !path_in_sparse_checkout(src, the_repository->index)) {
string_list_append(&only_match_skip_worktree, src); string_list_append(&only_match_skip_worktree, src);
skip_sparse = 1; skip_sparse = 1;
} }
if (!ignore_sparse && if (!ignore_sparse &&
!path_in_sparse_checkout(dst, &the_index)) { !path_in_sparse_checkout(dst, the_repository->index)) {
string_list_append(&only_match_skip_worktree, dst); string_list_append(&only_match_skip_worktree, dst);
skip_sparse = 1; skip_sparse = 1;
} }
@ -449,7 +449,7 @@ remove_entry:
int pos; int pos;
int sparse_and_dirty = 0; int sparse_and_dirty = 0;
struct checkout state = CHECKOUT_INIT; struct checkout state = CHECKOUT_INIT;
state.istate = &the_index; state.istate = the_repository->index;


if (force) if (force)
state.force = 1; state.force = 1;
@ -476,14 +476,14 @@ remove_entry:
if (mode & (WORKING_DIRECTORY | SKIP_WORKTREE_DIR)) if (mode & (WORKING_DIRECTORY | SKIP_WORKTREE_DIR))
continue; continue;


pos = index_name_pos(&the_index, src, strlen(src)); pos = index_name_pos(the_repository->index, src, strlen(src));
assert(pos >= 0); assert(pos >= 0);
if (!(mode & SPARSE) && !lstat(src, &st)) if (!(mode & SPARSE) && !lstat(src, &st))
sparse_and_dirty = ie_modified(&the_index, sparse_and_dirty = ie_modified(the_repository->index,
the_index.cache[pos], the_repository->index->cache[pos],
&st, &st,
0); 0);
rename_index_entry_at(&the_index, pos, dst); rename_index_entry_at(the_repository->index, pos, dst);


if (ignore_sparse && if (ignore_sparse &&
core_apply_sparse_checkout && core_apply_sparse_checkout &&
@ -495,11 +495,11 @@ remove_entry:
* should be added in a future patch. * should be added in a future patch.
*/ */
if ((mode & SPARSE) && if ((mode & SPARSE) &&
path_in_sparse_checkout(dst, &the_index)) { path_in_sparse_checkout(dst, the_repository->index)) {
/* from out-of-cone to in-cone */ /* from out-of-cone to in-cone */
int dst_pos = index_name_pos(&the_index, dst, int dst_pos = index_name_pos(the_repository->index, dst,
strlen(dst)); strlen(dst));
struct cache_entry *dst_ce = the_index.cache[dst_pos]; struct cache_entry *dst_ce = the_repository->index->cache[dst_pos];


dst_ce->ce_flags &= ~CE_SKIP_WORKTREE; dst_ce->ce_flags &= ~CE_SKIP_WORKTREE;


@ -507,11 +507,11 @@ remove_entry:
die(_("cannot checkout %s"), dst_ce->name); die(_("cannot checkout %s"), dst_ce->name);
} else if ((dst_mode & (SKIP_WORKTREE_DIR | SPARSE)) && } else if ((dst_mode & (SKIP_WORKTREE_DIR | SPARSE)) &&
!(mode & SPARSE) && !(mode & SPARSE) &&
!path_in_sparse_checkout(dst, &the_index)) { !path_in_sparse_checkout(dst, the_repository->index)) {
/* from in-cone to out-of-cone */ /* from in-cone to out-of-cone */
int dst_pos = index_name_pos(&the_index, dst, int dst_pos = index_name_pos(the_repository->index, dst,
strlen(dst)); strlen(dst));
struct cache_entry *dst_ce = the_index.cache[dst_pos]; struct cache_entry *dst_ce = the_repository->index->cache[dst_pos];


/* /*
* if src is clean, it will suffice to remove it * if src is clean, it will suffice to remove it
@ -559,9 +559,9 @@ remove_entry:
advise_on_moving_dirty_path(&dirty_paths); advise_on_moving_dirty_path(&dirty_paths);


if (gitmodules_modified) if (gitmodules_modified)
stage_updated_gitmodules(&the_index); stage_updated_gitmodules(the_repository->index);


if (write_locked_index(&the_index, &lock_file, if (write_locked_index(the_repository->index, &lock_file,
COMMIT_LOCK | SKIP_IF_UNCHANGED)) COMMIT_LOCK | SKIP_IF_UNCHANGED))
die(_("Unable to write new index file")); die(_("Unable to write new index file"));



4
builtin/pull.c
View File

@ -5,7 +5,7 @@
* *
* Fetch one or more remote refs and merge it/them into the current HEAD. * Fetch one or more remote refs and merge it/them into the current HEAD.
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "advice.h" #include "advice.h"
#include "config.h" #include "config.h"
@ -1044,7 +1044,7 @@ int cmd_pull(int argc, const char **argv, const char *prefix)
if (opt_autostash == -1) if (opt_autostash == -1)
opt_autostash = config_autostash; opt_autostash = config_autostash;


if (is_null_oid(&orig_head) && !is_index_unborn(&the_index)) if (is_null_oid(&orig_head) && !is_index_unborn(the_repository->index))
die(_("Updating an unborn branch with changes added to the index.")); die(_("Updating an unborn branch with changes added to the index."));


if (!opt_autostash) if (!opt_autostash)

15
builtin/read-tree.c
View File

@ -4,7 +4,6 @@
* Copyright (C) Linus Torvalds, 2005 * Copyright (C) Linus Torvalds, 2005
*/ */


#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "gettext.h" #include "gettext.h"
@ -159,8 +158,8 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)


memset(&opts, 0, sizeof(opts)); memset(&opts, 0, sizeof(opts));
opts.head_idx = -1; opts.head_idx = -1;
opts.src_index = &the_index; opts.src_index = the_repository->index;
opts.dst_index = &the_index; opts.dst_index = the_repository->index;


git_config(git_read_tree_config, NULL); git_config(git_read_tree_config, NULL);


@ -197,7 +196,7 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
die(_("You need to resolve your current index first")); die(_("You need to resolve your current index first"));
stage = opts.merge = 1; stage = opts.merge = 1;
} }
resolve_undo_clear_index(&the_index); resolve_undo_clear_index(the_repository->index);


for (i = 0; i < argc; i++) { for (i = 0; i < argc; i++) {
const char *arg = argv[i]; const char *arg = argv[i];
@ -225,7 +224,7 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
setup_work_tree(); setup_work_tree();


if (opts.skip_sparse_checkout) if (opts.skip_sparse_checkout)
ensure_full_index(&the_index); ensure_full_index(the_repository->index);


if (opts.merge) { if (opts.merge) {
switch (stage - 1) { switch (stage - 1) {
@ -237,7 +236,7 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
break; break;
case 2: case 2:
opts.fn = twoway_merge; opts.fn = twoway_merge;
opts.initial_checkout = is_index_unborn(&the_index); opts.initial_checkout = is_index_unborn(the_repository->index);
break; break;
case 3: case 3:
default: default:
@ -258,7 +257,7 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
if (nr_trees == 1 && !opts.prefix) if (nr_trees == 1 && !opts.prefix)
opts.skip_cache_tree_update = 1; opts.skip_cache_tree_update = 1;


cache_tree_free(&the_index.cache_tree); cache_tree_free(&the_repository->index->cache_tree);
for (i = 0; i < nr_trees; i++) { for (i = 0; i < nr_trees; i++) {
struct tree *tree = trees[i]; struct tree *tree = trees[i];
if (parse_tree(tree) < 0) if (parse_tree(tree) < 0)
@ -282,7 +281,7 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
the_repository->index, the_repository->index,
trees[0]); trees[0]);


if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
die("unable to write new index file"); die("unable to write new index file");
return 0; return 0;
} }

3
builtin/rebase.c
View File

@ -4,7 +4,6 @@
* Copyright (c) 2018 Pratik Karki * Copyright (c) 2018 Pratik Karki
*/ */


#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "environment.h" #include "environment.h"
@ -295,7 +294,7 @@ static int do_interactive_rebase(struct rebase_options *opts, unsigned flags)
if (ret) if (ret)
error(_("could not generate todo list")); error(_("could not generate todo list"));
else { else {
discard_index(&the_index); discard_index(the_repository->index);
if (todo_list_parse_insn_buffer(the_repository, todo_list.buf.buf, if (todo_list_parse_insn_buffer(the_repository, todo_list.buf.buf,
&todo_list)) &todo_list))
BUG("unusable todo list"); BUG("unusable todo list");

1
builtin/replay.c
View File

@ -2,7 +2,6 @@
* "git replay" builtin command * "git replay" builtin command
*/ */


#define USE_THE_INDEX_VARIABLE
#include "git-compat-util.h" #include "git-compat-util.h"


#include "builtin.h" #include "builtin.h"

32
builtin/reset.c
View File

@ -7,7 +7,7 @@
* *
* Copyright (c) 2005, 2006 Linus Torvalds and Junio C Hamano * Copyright (c) 2005, 2006 Linus Torvalds and Junio C Hamano
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "advice.h" #include "advice.h"
#include "config.h" #include "config.h"
@ -66,8 +66,8 @@ static int reset_index(const char *ref, const struct object_id *oid, int reset_t


memset(&opts, 0, sizeof(opts)); memset(&opts, 0, sizeof(opts));
opts.head_idx = 1; opts.head_idx = 1;
opts.src_index = &the_index; opts.src_index = the_repository->index;
opts.dst_index = &the_index; opts.dst_index = the_repository->index;
opts.fn = oneway_merge; opts.fn = oneway_merge;
opts.merge = 1; opts.merge = 1;
init_checkout_metadata(&opts.meta, ref, oid, NULL); init_checkout_metadata(&opts.meta, ref, oid, NULL);
@ -159,11 +159,11 @@ static void update_index_from_diff(struct diff_queue_struct *q,
struct cache_entry *ce; struct cache_entry *ce;


if (!is_in_reset_tree && !intent_to_add) { if (!is_in_reset_tree && !intent_to_add) {
remove_file_from_index(&the_index, one->path); remove_file_from_index(the_repository->index, one->path);
continue; continue;
} }


ce = make_cache_entry(&the_index, one->mode, &one->oid, one->path, ce = make_cache_entry(the_repository->index, one->mode, &one->oid, one->path,
0, 0); 0, 0);


/* /*
@ -174,9 +174,9 @@ static void update_index_from_diff(struct diff_queue_struct *q,
* if this entry is outside the sparse cone - this is necessary * if this entry is outside the sparse cone - this is necessary
* to properly construct the reset sparse directory. * to properly construct the reset sparse directory.
*/ */
pos = index_name_pos(&the_index, one->path, strlen(one->path)); pos = index_name_pos(the_repository->index, one->path, strlen(one->path));
if ((pos >= 0 && ce_skip_worktree(the_index.cache[pos])) || if ((pos >= 0 && ce_skip_worktree(the_repository->index->cache[pos])) ||
(pos < 0 && !path_in_sparse_checkout(one->path, &the_index))) (pos < 0 && !path_in_sparse_checkout(one->path, the_repository->index)))
ce->ce_flags |= CE_SKIP_WORKTREE; ce->ce_flags |= CE_SKIP_WORKTREE;


if (!ce) if (!ce)
@ -186,7 +186,7 @@ static void update_index_from_diff(struct diff_queue_struct *q,
ce->ce_flags |= CE_INTENT_TO_ADD; ce->ce_flags |= CE_INTENT_TO_ADD;
set_object_name_for_intent_to_add_entry(ce); set_object_name_for_intent_to_add_entry(ce);
} }
add_index_entry(&the_index, ce, add_index_entry(the_repository->index, ce,
ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE); ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
} }
} }
@ -208,8 +208,8 @@ static int read_from_tree(const struct pathspec *pathspec,
opt.change = diff_change; opt.change = diff_change;
opt.add_remove = diff_addremove; opt.add_remove = diff_addremove;


if (pathspec->nr && pathspec_needs_expanded_index(&the_index, pathspec)) if (pathspec->nr && pathspec_needs_expanded_index(the_repository->index, pathspec))
ensure_full_index(&the_index); ensure_full_index(the_repository->index);


if (do_diff_cache(tree_oid, &opt)) if (do_diff_cache(tree_oid, &opt))
return 1; return 1;
@ -235,7 +235,7 @@ static void set_reflog_message(struct strbuf *sb, const char *action,


static void die_if_unmerged_cache(int reset_type) static void die_if_unmerged_cache(int reset_type)
{ {
if (is_merge() || unmerged_index(&the_index)) if (is_merge() || unmerged_index(the_repository->index))
die(_("Cannot do a %s reset in the middle of a merge."), die(_("Cannot do a %s reset in the middle of a merge."),
_(reset_type_names[reset_type])); _(reset_type_names[reset_type]));


@ -470,12 +470,12 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
update_ref_status = 1; update_ref_status = 1;
goto cleanup; goto cleanup;
} }
the_index.updated_skipworktree = 1; the_repository->index->updated_skipworktree = 1;
if (!no_refresh && get_git_work_tree()) { if (!no_refresh && get_git_work_tree()) {
uint64_t t_begin, t_delta_in_ms; uint64_t t_begin, t_delta_in_ms;


t_begin = getnanotime(); t_begin = getnanotime();
refresh_index(&the_index, flags, NULL, NULL, refresh_index(the_repository->index, flags, NULL, NULL,
_("Unstaged changes after reset:")); _("Unstaged changes after reset:"));
t_delta_in_ms = (getnanotime() - t_begin) / 1000000; t_delta_in_ms = (getnanotime() - t_begin) / 1000000;
if (!quiet && advice_enabled(ADVICE_RESET_NO_REFRESH_WARNING) && t_delta_in_ms > REFRESH_INDEX_DELAY_WARNING_IN_MS) { if (!quiet && advice_enabled(ADVICE_RESET_NO_REFRESH_WARNING) && t_delta_in_ms > REFRESH_INDEX_DELAY_WARNING_IN_MS) {
@ -501,7 +501,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
free(ref); free(ref);
} }


if (write_locked_index(&the_index, &lock, COMMIT_LOCK)) if (write_locked_index(the_repository->index, &lock, COMMIT_LOCK))
die(_("Could not write new index file.")); die(_("Could not write new index file."));
} }


@ -516,7 +516,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
if (!pathspec.nr) if (!pathspec.nr)
remove_branch_state(the_repository, 0); remove_branch_state(the_repository, 0);


discard_index(&the_index); discard_index(the_repository->index);


cleanup: cleanup:
clear_pathspec(&pathspec); clear_pathspec(&pathspec);

6
builtin/rev-parse.c
View File

@ -3,7 +3,7 @@
* *
* Copyright (C) Linus Torvalds, 2005 * Copyright (C) Linus Torvalds, 2005
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "config.h" #include "config.h"
@ -1049,8 +1049,8 @@ int cmd_rev_parse(int argc, const char **argv, const char *prefix)
if (!strcmp(arg, "--shared-index-path")) { if (!strcmp(arg, "--shared-index-path")) {
if (repo_read_index(the_repository) < 0) if (repo_read_index(the_repository) < 0)
die(_("Could not read the index")); die(_("Could not read the index"));
if (the_index.split_index) { if (the_repository->index->split_index) {
const struct object_id *oid = &the_index.split_index->base_oid; const struct object_id *oid = &the_repository->index->split_index->base_oid;
const char *path = git_path("sharedindex.%s", oid_to_hex(oid)); const char *path = git_path("sharedindex.%s", oid_to_hex(oid));
print_path(path, prefix, format, DEFAULT_RELATIVE); print_path(path, prefix, format, DEFAULT_RELATIVE);
} }

40
builtin/rm.c
View File

@ -3,7 +3,7 @@
* *
* Copyright (C) Linus Torvalds 2006 * Copyright (C) Linus Torvalds 2006
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "advice.h" #include "advice.h"
#include "config.h" #include "config.h"
@ -41,8 +41,8 @@ static int get_ours_cache_pos(const char *path, int pos)
{ {
int i = -pos - 1; int i = -pos - 1;


while ((i < the_index.cache_nr) && !strcmp(the_index.cache[i]->name, path)) { while ((i < the_repository->index->cache_nr) && !strcmp(the_repository->index->cache[i]->name, path)) {
if (ce_stage(the_index.cache[i]) == 2) if (ce_stage(the_repository->index->cache[i]) == 2)
return i; return i;
i++; i++;
} }
@ -78,13 +78,13 @@ static void submodules_absorb_gitdir_if_needed(void)
int pos; int pos;
const struct cache_entry *ce; const struct cache_entry *ce;


pos = index_name_pos(&the_index, name, strlen(name)); pos = index_name_pos(the_repository->index, name, strlen(name));
if (pos < 0) { if (pos < 0) {
pos = get_ours_cache_pos(name, pos); pos = get_ours_cache_pos(name, pos);
if (pos < 0) if (pos < 0)
continue; continue;
} }
ce = the_index.cache[pos]; ce = the_repository->index->cache[pos];


if (!S_ISGITLINK(ce->ce_mode) || if (!S_ISGITLINK(ce->ce_mode) ||
!file_exists(ce->name) || !file_exists(ce->name) ||
@ -122,7 +122,7 @@ static int check_local_mod(struct object_id *head, int index_only)
int local_changes = 0; int local_changes = 0;
int staged_changes = 0; int staged_changes = 0;


pos = index_name_pos(&the_index, name, strlen(name)); pos = index_name_pos(the_repository->index, name, strlen(name));
if (pos < 0) { if (pos < 0) {
/* /*
* Skip unmerged entries except for populated submodules * Skip unmerged entries except for populated submodules
@ -132,11 +132,11 @@ static int check_local_mod(struct object_id *head, int index_only)
if (pos < 0) if (pos < 0)
continue; continue;


if (!S_ISGITLINK(the_index.cache[pos]->ce_mode) || if (!S_ISGITLINK(the_repository->index->cache[pos]->ce_mode) ||
is_empty_dir(name)) is_empty_dir(name))
continue; continue;
} }
ce = the_index.cache[pos]; ce = the_repository->index->cache[pos];


if (lstat(ce->name, &st) < 0) { if (lstat(ce->name, &st) < 0) {
if (!is_missing_file_error(errno)) if (!is_missing_file_error(errno))
@ -173,7 +173,7 @@ static int check_local_mod(struct object_id *head, int index_only)
* Is the index different from the file in the work tree? * Is the index different from the file in the work tree?
* If it's a submodule, is its work tree modified? * If it's a submodule, is its work tree modified?
*/ */
if (ie_match_stat(&the_index, ce, &st, 0) || if (ie_match_stat(the_repository->index, ce, &st, 0) ||
(S_ISGITLINK(ce->ce_mode) && (S_ISGITLINK(ce->ce_mode) &&
bad_to_remove_submodule(ce->name, bad_to_remove_submodule(ce->name,
SUBMODULE_REMOVAL_DIE_ON_ERROR | SUBMODULE_REMOVAL_DIE_ON_ERROR |
@ -301,27 +301,27 @@ int cmd_rm(int argc, const char **argv, const char *prefix)
if (repo_read_index(the_repository) < 0) if (repo_read_index(the_repository) < 0)
die(_("index file corrupt")); die(_("index file corrupt"));


refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &pathspec, NULL, NULL); refresh_index(the_repository->index, REFRESH_QUIET|REFRESH_UNMERGED, &pathspec, NULL, NULL);


seen = xcalloc(pathspec.nr, 1); seen = xcalloc(pathspec.nr, 1);


if (pathspec_needs_expanded_index(&the_index, &pathspec)) if (pathspec_needs_expanded_index(the_repository->index, &pathspec))
ensure_full_index(&the_index); ensure_full_index(the_repository->index);


for (i = 0; i < the_index.cache_nr; i++) { for (i = 0; i < the_repository->index->cache_nr; i++) {
const struct cache_entry *ce = the_index.cache[i]; const struct cache_entry *ce = the_repository->index->cache[i];


if (!include_sparse && if (!include_sparse &&
(ce_skip_worktree(ce) || (ce_skip_worktree(ce) ||
!path_in_sparse_checkout(ce->name, &the_index))) !path_in_sparse_checkout(ce->name, the_repository->index)))
continue; continue;
if (!ce_path_match(&the_index, ce, &pathspec, seen)) if (!ce_path_match(the_repository->index, ce, &pathspec, seen))
continue; continue;
ALLOC_GROW(list.entry, list.nr + 1, list.alloc); ALLOC_GROW(list.entry, list.nr + 1, list.alloc);
list.entry[list.nr].name = xstrdup(ce->name); list.entry[list.nr].name = xstrdup(ce->name);
list.entry[list.nr].is_submodule = S_ISGITLINK(ce->ce_mode); list.entry[list.nr].is_submodule = S_ISGITLINK(ce->ce_mode);
if (list.entry[list.nr++].is_submodule && if (list.entry[list.nr++].is_submodule &&
!is_staging_gitmodules_ok(&the_index)) !is_staging_gitmodules_ok(the_repository->index))
die(_("please stage your changes to .gitmodules or stash them to proceed")); die(_("please stage your changes to .gitmodules or stash them to proceed"));
} }


@ -391,7 +391,7 @@ int cmd_rm(int argc, const char **argv, const char *prefix)
if (!quiet) if (!quiet)
printf("rm '%s'\n", path); printf("rm '%s'\n", path);


if (remove_file_from_index(&the_index, path)) if (remove_file_from_index(the_repository->index, path))
die(_("git rm: unable to remove %s"), path); die(_("git rm: unable to remove %s"), path);
} }


@ -432,10 +432,10 @@ int cmd_rm(int argc, const char **argv, const char *prefix)
} }
strbuf_release(&buf); strbuf_release(&buf);
if (gitmodules_modified) if (gitmodules_modified)
stage_updated_gitmodules(&the_index); stage_updated_gitmodules(the_repository->index);
} }


if (write_locked_index(&the_index, &lock_file, if (write_locked_index(the_repository->index, &lock_file,
COMMIT_LOCK | SKIP_IF_UNCHANGED)) COMMIT_LOCK | SKIP_IF_UNCHANGED))
die(_("Unable to write new index file")); die(_("Unable to write new index file"));



45
builtin/stash.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "config.h" #include "config.h"
@ -273,7 +272,7 @@ static int reset_tree(struct object_id *i_tree, int update, int reset)
struct lock_file lock_file = LOCK_INIT; struct lock_file lock_file = LOCK_INIT;


repo_read_index_preload(the_repository, NULL, 0); repo_read_index_preload(the_repository, NULL, 0);
if (refresh_index(&the_index, REFRESH_QUIET, NULL, NULL, NULL)) if (refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL, NULL))
return -1; return -1;


repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR); repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
@ -287,8 +286,8 @@ static int reset_tree(struct object_id *i_tree, int update, int reset)
init_tree_desc(t, &tree->object.oid, tree->buffer, tree->size); init_tree_desc(t, &tree->object.oid, tree->buffer, tree->size);


opts.head_idx = 1; opts.head_idx = 1;
opts.src_index = &the_index; opts.src_index = the_repository->index;
opts.dst_index = &the_index; opts.dst_index = the_repository->index;
opts.merge = 1; opts.merge = 1;
opts.reset = reset ? UNPACK_RESET_PROTECT_UNTRACKED : 0; opts.reset = reset ? UNPACK_RESET_PROTECT_UNTRACKED : 0;
opts.update = update; opts.update = update;
@ -299,7 +298,7 @@ static int reset_tree(struct object_id *i_tree, int update, int reset)
if (unpack_trees(nr_trees, t, &opts)) if (unpack_trees(nr_trees, t, &opts))
return -1; return -1;


if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
return error(_("unable to write new index file")); return error(_("unable to write new index file"));


return 0; return 0;
@ -430,7 +429,7 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
state.force = 1; state.force = 1;
state.quiet = 1; state.quiet = 1;
state.refresh_cache = 1; state.refresh_cache = 1;
state.istate = &the_index; state.istate = the_repository->index;


/* /*
* Step 1: get a difference between orig_tree (which corresponding * Step 1: get a difference between orig_tree (which corresponding
@ -454,7 +453,7 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)


/* Look up the path's position in the current index. */ /* Look up the path's position in the current index. */
p = diff_queued_diff.queue[i]; p = diff_queued_diff.queue[i];
pos = index_name_pos(&the_index, p->two->path, pos = index_name_pos(the_repository->index, p->two->path,
strlen(p->two->path)); strlen(p->two->path));


/* /*
@ -465,10 +464,10 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
* path, but left it out of the working tree, then clear the * path, but left it out of the working tree, then clear the
* SKIP_WORKTREE bit and write it to the working tree. * SKIP_WORKTREE bit and write it to the working tree.
*/ */
if (pos >= 0 && ce_skip_worktree(the_index.cache[pos])) { if (pos >= 0 && ce_skip_worktree(the_repository->index->cache[pos])) {
struct stat st; struct stat st;


ce = the_index.cache[pos]; ce = the_repository->index->cache[pos];
if (!lstat(ce->name, &st)) { if (!lstat(ce->name, &st)) {
/* Conflicting path present; relocate it */ /* Conflicting path present; relocate it */
struct strbuf new_path = STRBUF_INIT; struct strbuf new_path = STRBUF_INIT;
@ -504,12 +503,12 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
if (pos < 0) if (pos < 0)
option = ADD_CACHE_OK_TO_ADD; option = ADD_CACHE_OK_TO_ADD;


ce = make_cache_entry(&the_index, ce = make_cache_entry(the_repository->index,
p->one->mode, p->one->mode,
&p->one->oid, &p->one->oid,
p->one->path, p->one->path,
0, 0); 0, 0);
add_index_entry(&the_index, ce, option); add_index_entry(the_repository->index, ce, option);
} }
} }
diff_flush(&diff_opts); diff_flush(&diff_opts);
@ -518,7 +517,7 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
* Step 4: write the new index to disk * Step 4: write the new index to disk
*/ */
repo_hold_locked_index(the_repository, &lock, LOCK_DIE_ON_ERROR); repo_hold_locked_index(the_repository, &lock, LOCK_DIE_ON_ERROR);
if (write_locked_index(&the_index, &lock, if (write_locked_index(the_repository->index, &lock,
COMMIT_LOCK | SKIP_IF_UNCHANGED)) COMMIT_LOCK | SKIP_IF_UNCHANGED))
die(_("could not write index")); die(_("could not write index"));
} }
@ -539,7 +538,7 @@ static int do_apply_stash(const char *prefix, struct stash_info *info,
NULL, NULL, NULL)) NULL, NULL, NULL))
return error(_("could not write index")); return error(_("could not write index"));


if (write_index_as_tree(&c_tree, &the_index, get_index_file(), 0, if (write_index_as_tree(&c_tree, the_repository->index, get_index_file(), 0,
NULL)) NULL))
return error(_("cannot apply a stash in the middle of a merge")); return error(_("cannot apply a stash in the middle of a merge"));


@ -562,14 +561,14 @@ static int do_apply_stash(const char *prefix, struct stash_info *info,
return error(_("conflicts in index. " return error(_("conflicts in index. "
"Try without --index.")); "Try without --index."));


discard_index(&the_index); discard_index(the_repository->index);
repo_read_index(the_repository); repo_read_index(the_repository);
if (write_index_as_tree(&index_tree, &the_index, if (write_index_as_tree(&index_tree, the_repository->index,
get_index_file(), 0, NULL)) get_index_file(), 0, NULL))
return error(_("could not save index tree")); return error(_("could not save index tree"));


reset_head(); reset_head();
discard_index(&the_index); discard_index(the_repository->index);
repo_read_index(the_repository); repo_read_index(the_repository);
} }
} }
@ -875,8 +874,8 @@ static void diff_include_untracked(const struct stash_info *info, struct diff_op
} }


unpack_tree_opt.head_idx = -1; unpack_tree_opt.head_idx = -1;
unpack_tree_opt.src_index = &the_index; unpack_tree_opt.src_index = the_repository->index;
unpack_tree_opt.dst_index = &the_index; unpack_tree_opt.dst_index = the_repository->index;
unpack_tree_opt.merge = 1; unpack_tree_opt.merge = 1;
unpack_tree_opt.fn = stash_worktree_untracked_merge; unpack_tree_opt.fn = stash_worktree_untracked_merge;


@ -1395,7 +1394,7 @@ static int do_create_stash(const struct pathspec *ps, struct strbuf *stash_msg_b


strbuf_addf(&commit_tree_label, "index on %s\n", msg.buf); strbuf_addf(&commit_tree_label, "index on %s\n", msg.buf);
commit_list_insert(head_commit, &parents); commit_list_insert(head_commit, &parents);
if (write_index_as_tree(&info->i_tree, &the_index, get_index_file(), 0, if (write_index_as_tree(&info->i_tree, the_repository->index, get_index_file(), 0,
NULL) || NULL) ||
commit_tree(commit_tree_label.buf, commit_tree_label.len, commit_tree(commit_tree_label.buf, commit_tree_label.len,
&info->i_tree, parents, &info->i_commit, NULL, NULL)) { &info->i_tree, parents, &info->i_commit, NULL, NULL)) {
@ -1540,9 +1539,9 @@ static int do_push_stash(const struct pathspec *ps, const char *stash_msg, int q
char *ps_matched = xcalloc(ps->nr, 1); char *ps_matched = xcalloc(ps->nr, 1);


/* TODO: audit for interaction with sparse-index. */ /* TODO: audit for interaction with sparse-index. */
ensure_full_index(&the_index); ensure_full_index(the_repository->index);
for (i = 0; i < the_index.cache_nr; i++) for (i = 0; i < the_repository->index->cache_nr; i++)
ce_path_match(&the_index, the_index.cache[i], ps, ce_path_match(the_repository->index, the_repository->index->cache[i], ps,
ps_matched); ps_matched);


if (report_path_error(ps_matched, ps)) { if (report_path_error(ps_matched, ps)) {
@ -1612,7 +1611,7 @@ static int do_push_stash(const struct pathspec *ps, const char *stash_msg, int q
goto done; goto done;
} }
} }
discard_index(&the_index); discard_index(the_repository->index);
if (ps->nr) { if (ps->nr) {
struct child_process cp_add = CHILD_PROCESS_INIT; struct child_process cp_add = CHILD_PROCESS_INIT;
struct child_process cp_diff = CHILD_PROCESS_INIT; struct child_process cp_diff = CHILD_PROCESS_INIT;

21
builtin/submodule--helper.c
View File

@ -1,4 +1,3 @@
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "abspath.h" #include "abspath.h"
#include "environment.h" #include "environment.h"
@ -207,18 +206,18 @@ static int module_list_compute(const char **argv,
if (repo_read_index(the_repository) < 0) if (repo_read_index(the_repository) < 0)
die(_("index file corrupt")); die(_("index file corrupt"));


for (i = 0; i < the_index.cache_nr; i++) { for (i = 0; i < the_repository->index->cache_nr; i++) {
const struct cache_entry *ce = the_index.cache[i]; const struct cache_entry *ce = the_repository->index->cache[i];


if (!match_pathspec(&the_index, pathspec, ce->name, ce_namelen(ce), if (!match_pathspec(the_repository->index, pathspec, ce->name, ce_namelen(ce),
0, ps_matched, 1) || 0, ps_matched, 1) ||
!S_ISGITLINK(ce->ce_mode)) !S_ISGITLINK(ce->ce_mode))
continue; continue;


ALLOC_GROW(list->entries, list->nr + 1, list->alloc); ALLOC_GROW(list->entries, list->nr + 1, list->alloc);
list->entries[list->nr++] = ce; list->entries[list->nr++] = ce;
while (i + 1 < the_index.cache_nr && while (i + 1 < the_repository->index->cache_nr &&
!strcmp(ce->name, the_index.cache[i + 1]->name)) !strcmp(ce->name, the_repository->index->cache[i + 1]->name))
/* /*
* Skip entries with the same name in different stages * Skip entries with the same name in different stages
* to make sure an entry is returned only once. * to make sure an entry is returned only once.
@ -907,7 +906,7 @@ static void generate_submodule_summary(struct summary_cb *info,
int fd = open(p->sm_path, O_RDONLY); int fd = open(p->sm_path, O_RDONLY);


if (fd < 0 || fstat(fd, &st) < 0 || if (fd < 0 || fstat(fd, &st) < 0 ||
index_fd(&the_index, &p->oid_dst, fd, &st, OBJ_BLOB, index_fd(the_repository->index, &p->oid_dst, fd, &st, OBJ_BLOB,
p->sm_path, 0)) p->sm_path, 0))
error(_("couldn't hash object from '%s'"), p->sm_path); error(_("couldn't hash object from '%s'"), p->sm_path);
} else { } else {
@ -3243,21 +3242,21 @@ static void die_on_index_match(const char *path, int force)
char *ps_matched = xcalloc(ps.nr, 1); char *ps_matched = xcalloc(ps.nr, 1);


/* TODO: audit for interaction with sparse-index. */ /* TODO: audit for interaction with sparse-index. */
ensure_full_index(&the_index); ensure_full_index(the_repository->index);


/* /*
* Since there is only one pathspec, we just need to * Since there is only one pathspec, we just need to
* check ps_matched[0] to know if a cache entry matched. * check ps_matched[0] to know if a cache entry matched.
*/ */
for (i = 0; i < the_index.cache_nr; i++) { for (i = 0; i < the_repository->index->cache_nr; i++) {
ce_path_match(&the_index, the_index.cache[i], &ps, ce_path_match(the_repository->index, the_repository->index->cache[i], &ps,
ps_matched); ps_matched);


if (ps_matched[0]) { if (ps_matched[0]) {
if (!force) if (!force)
die(_("'%s' already exists in the index"), die(_("'%s' already exists in the index"),
path); path);
if (!S_ISGITLINK(the_index.cache[i]->ce_mode)) if (!S_ISGITLINK(the_repository->index->cache[i]->ce_mode))
die(_("'%s' already exists in the index " die(_("'%s' already exists in the index "
"and is not a submodule"), path); "and is not a submodule"), path);
break; break;

122
builtin/update-index.c
View File

@ -3,7 +3,7 @@
* *
* Copyright (C) Linus Torvalds, 2005 * Copyright (C) Linus Torvalds, 2005
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "bulk-checkin.h" #include "bulk-checkin.h"
#include "config.h" #include "config.h"
@ -247,16 +247,16 @@ done:
static int mark_ce_flags(const char *path, int flag, int mark) static int mark_ce_flags(const char *path, int flag, int mark)
{ {
int namelen = strlen(path); int namelen = strlen(path);
int pos = index_name_pos(&the_index, path, namelen); int pos = index_name_pos(the_repository->index, path, namelen);
if (0 <= pos) { if (0 <= pos) {
mark_fsmonitor_invalid(&the_index, the_index.cache[pos]); mark_fsmonitor_invalid(the_repository->index, the_repository->index->cache[pos]);
if (mark) if (mark)
the_index.cache[pos]->ce_flags |= flag; the_repository->index->cache[pos]->ce_flags |= flag;
else else
the_index.cache[pos]->ce_flags &= ~flag; the_repository->index->cache[pos]->ce_flags &= ~flag;
the_index.cache[pos]->ce_flags |= CE_UPDATE_IN_BASE; the_repository->index->cache[pos]->ce_flags |= CE_UPDATE_IN_BASE;
cache_tree_invalidate_path(&the_index, path); cache_tree_invalidate_path(the_repository->index, path);
the_index.cache_changed |= CE_ENTRY_CHANGED; the_repository->index->cache_changed |= CE_ENTRY_CHANGED;
return 0; return 0;
} }
return -1; return -1;
@ -266,7 +266,7 @@ static int remove_one_path(const char *path)
{ {
if (!allow_remove) if (!allow_remove)
return error("%s: does not exist and --remove not passed", path); return error("%s: does not exist and --remove not passed", path);
if (remove_file_from_index(&the_index, path)) if (remove_file_from_index(the_repository->index, path))
return error("%s: cannot remove from the index", path); return error("%s: cannot remove from the index", path);
return 0; return 0;
} }
@ -291,24 +291,24 @@ static int add_one_path(const struct cache_entry *old, const char *path, int len
struct cache_entry *ce; struct cache_entry *ce;


/* Was the old index entry already up-to-date? */ /* Was the old index entry already up-to-date? */
if (old && !ce_stage(old) && !ie_match_stat(&the_index, old, st, 0)) if (old && !ce_stage(old) && !ie_match_stat(the_repository->index, old, st, 0))
return 0; return 0;


ce = make_empty_cache_entry(&the_index, len); ce = make_empty_cache_entry(the_repository->index, len);
memcpy(ce->name, path, len); memcpy(ce->name, path, len);
ce->ce_flags = create_ce_flags(0); ce->ce_flags = create_ce_flags(0);
ce->ce_namelen = len; ce->ce_namelen = len;
fill_stat_cache_info(&the_index, ce, st); fill_stat_cache_info(the_repository->index, ce, st);
ce->ce_mode = ce_mode_from_stat(old, st->st_mode); ce->ce_mode = ce_mode_from_stat(old, st->st_mode);


if (index_path(&the_index, &ce->oid, path, st, if (index_path(the_repository->index, &ce->oid, path, st,
info_only ? 0 : HASH_WRITE_OBJECT)) { info_only ? 0 : HASH_WRITE_OBJECT)) {
discard_cache_entry(ce); discard_cache_entry(ce);
return -1; return -1;
} }
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0; option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0; option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
if (add_index_entry(&the_index, ce, option)) { if (add_index_entry(the_repository->index, ce, option)) {
discard_cache_entry(ce); discard_cache_entry(ce);
return error("%s: cannot add to the index - missing --add option?", path); return error("%s: cannot add to the index - missing --add option?", path);
} }
@ -341,11 +341,11 @@ static int add_one_path(const struct cache_entry *old, const char *path, int len
static int process_directory(const char *path, int len, struct stat *st) static int process_directory(const char *path, int len, struct stat *st)
{ {
struct object_id oid; struct object_id oid;
int pos = index_name_pos(&the_index, path, len); int pos = index_name_pos(the_repository->index, path, len);


/* Exact match: file or existing gitlink */ /* Exact match: file or existing gitlink */
if (pos >= 0) { if (pos >= 0) {
const struct cache_entry *ce = the_index.cache[pos]; const struct cache_entry *ce = the_repository->index->cache[pos];
if (S_ISGITLINK(ce->ce_mode)) { if (S_ISGITLINK(ce->ce_mode)) {


/* Do nothing to the index if there is no HEAD! */ /* Do nothing to the index if there is no HEAD! */
@ -360,8 +360,8 @@ static int process_directory(const char *path, int len, struct stat *st)


/* Inexact match: is there perhaps a subdirectory match? */ /* Inexact match: is there perhaps a subdirectory match? */
pos = -pos-1; pos = -pos-1;
while (pos < the_index.cache_nr) { while (pos < the_repository->index->cache_nr) {
const struct cache_entry *ce = the_index.cache[pos++]; const struct cache_entry *ce = the_repository->index->cache[pos++];


if (strncmp(ce->name, path, len)) if (strncmp(ce->name, path, len))
break; break;
@ -391,8 +391,8 @@ static int process_path(const char *path, struct stat *st, int stat_errno)
if (has_symlink_leading_path(path, len)) if (has_symlink_leading_path(path, len))
return error("'%s' is beyond a symbolic link", path); return error("'%s' is beyond a symbolic link", path);


pos = index_name_pos(&the_index, path, len); pos = index_name_pos(the_repository->index, path, len);
ce = pos < 0 ? NULL : the_index.cache[pos]; ce = pos < 0 ? NULL : the_repository->index->cache[pos];
if (ce && ce_skip_worktree(ce)) { if (ce && ce_skip_worktree(ce)) {
/* /*
* working directory version is assumed "good" * working directory version is assumed "good"
@ -400,7 +400,7 @@ static int process_path(const char *path, struct stat *st, int stat_errno)
* On the other hand, removing it from index should work * On the other hand, removing it from index should work
*/ */
if (!ignore_skip_worktree_entries && allow_remove && if (!ignore_skip_worktree_entries && allow_remove &&
remove_file_from_index(&the_index, path)) remove_file_from_index(the_repository->index, path))
return error("%s: cannot remove from the index", path); return error("%s: cannot remove from the index", path);
return 0; return 0;
} }
@ -428,7 +428,7 @@ static int add_cacheinfo(unsigned int mode, const struct object_id *oid,
return error("Invalid path '%s'", path); return error("Invalid path '%s'", path);


len = strlen(path); len = strlen(path);
ce = make_empty_cache_entry(&the_index, len); ce = make_empty_cache_entry(the_repository->index, len);


oidcpy(&ce->oid, oid); oidcpy(&ce->oid, oid);
memcpy(ce->name, path, len); memcpy(ce->name, path, len);
@ -439,7 +439,7 @@ static int add_cacheinfo(unsigned int mode, const struct object_id *oid,
ce->ce_flags |= CE_VALID; ce->ce_flags |= CE_VALID;
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0; option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0; option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
if (add_index_entry(&the_index, ce, option)) if (add_index_entry(the_repository->index, ce, option))
return error("%s: cannot add to the index - missing --add option?", return error("%s: cannot add to the index - missing --add option?",
path); path);
report("add '%s'", path); report("add '%s'", path);
@ -451,11 +451,11 @@ static void chmod_path(char flip, const char *path)
int pos; int pos;
struct cache_entry *ce; struct cache_entry *ce;


pos = index_name_pos(&the_index, path, strlen(path)); pos = index_name_pos(the_repository->index, path, strlen(path));
if (pos < 0) if (pos < 0)
goto fail; goto fail;
ce = the_index.cache[pos]; ce = the_repository->index->cache[pos];
if (chmod_index_entry(&the_index, ce, flip) < 0) if (chmod_index_entry(the_repository->index, ce, flip) < 0)
goto fail; goto fail;


report("chmod %cx '%s'", flip, path); report("chmod %cx '%s'", flip, path);
@ -498,7 +498,7 @@ static void update_one(const char *path)
} }


if (force_remove) { if (force_remove) {
if (remove_file_from_index(&the_index, path)) if (remove_file_from_index(the_repository->index, path))
die("git update-index: unable to remove %s", path); die("git update-index: unable to remove %s", path);
report("remove '%s'", path); report("remove '%s'", path);
return; return;
@ -581,7 +581,7 @@ static void read_index_info(int nul_term_line)


if (!mode) { if (!mode) {
/* mode == 0 means there is no such path -- remove */ /* mode == 0 means there is no such path -- remove */
if (remove_file_from_index(&the_index, path_name)) if (remove_file_from_index(the_repository->index, path_name))
die("git update-index: unable to remove %s", die("git update-index: unable to remove %s",
ptr); ptr);
} }
@ -622,12 +622,12 @@ static struct cache_entry *read_one_ent(const char *which,
error("%s: not in %s branch.", path, which); error("%s: not in %s branch.", path, which);
return NULL; return NULL;
} }
if (!the_index.sparse_index && mode == S_IFDIR) { if (!the_repository->index->sparse_index && mode == S_IFDIR) {
if (which) if (which)
error("%s: not a blob in %s branch.", path, which); error("%s: not a blob in %s branch.", path, which);
return NULL; return NULL;
} }
ce = make_empty_cache_entry(&the_index, namelen); ce = make_empty_cache_entry(the_repository->index, namelen);


oidcpy(&ce->oid, &oid); oidcpy(&ce->oid, &oid);
memcpy(ce->name, path, namelen); memcpy(ce->name, path, namelen);
@ -642,12 +642,12 @@ static int unresolve_one(const char *path)
struct string_list_item *item; struct string_list_item *item;
int res = 0; int res = 0;


if (!the_index.resolve_undo) if (!the_repository->index->resolve_undo)
return res; return res;
item = string_list_lookup(the_index.resolve_undo, path); item = string_list_lookup(the_repository->index->resolve_undo, path);
if (!item) if (!item)
return res; /* no resolve-undo record for the path */ return res; /* no resolve-undo record for the path */
res = unmerge_index_entry(&the_index, path, item->util, 0); res = unmerge_index_entry(the_repository->index, path, item->util, 0);
FREE_AND_NULL(item->util); FREE_AND_NULL(item->util);
return res; return res;
} }
@ -688,13 +688,13 @@ static int do_reupdate(const char **paths,
*/ */
has_head = 0; has_head = 0;
redo: redo:
for (pos = 0; pos < the_index.cache_nr; pos++) { for (pos = 0; pos < the_repository->index->cache_nr; pos++) {
const struct cache_entry *ce = the_index.cache[pos]; const struct cache_entry *ce = the_repository->index->cache[pos];
struct cache_entry *old = NULL; struct cache_entry *old = NULL;
int save_nr; int save_nr;
char *path; char *path;


if (ce_stage(ce) || !ce_path_match(&the_index, ce, &pathspec, NULL)) if (ce_stage(ce) || !ce_path_match(the_repository->index, ce, &pathspec, NULL))
continue; continue;
if (has_head) if (has_head)
old = read_one_ent(NULL, &head_oid, old = read_one_ent(NULL, &head_oid,
@ -710,7 +710,7 @@ static int do_reupdate(const char **paths,
* to process each path individually * to process each path individually
*/ */
if (S_ISSPARSEDIR(ce->ce_mode)) { if (S_ISSPARSEDIR(ce->ce_mode)) {
ensure_full_index(&the_index); ensure_full_index(the_repository->index);
goto redo; goto redo;
} }


@ -718,12 +718,12 @@ static int do_reupdate(const char **paths,
* path anymore, in which case, under 'allow_remove', * path anymore, in which case, under 'allow_remove',
* or worse yet 'allow_replace', active_nr may decrease. * or worse yet 'allow_replace', active_nr may decrease.
*/ */
save_nr = the_index.cache_nr; save_nr = the_repository->index->cache_nr;
path = xstrdup(ce->name); path = xstrdup(ce->name);
update_one(path); update_one(path);
free(path); free(path);
discard_cache_entry(old); discard_cache_entry(old);
if (save_nr != the_index.cache_nr) if (save_nr != the_repository->index->cache_nr)
goto redo; goto redo;
} }
clear_pathspec(&pathspec); clear_pathspec(&pathspec);
@ -739,9 +739,9 @@ static int refresh(struct refresh_params *o, unsigned int flag)
{ {
setup_work_tree(); setup_work_tree();
repo_read_index(the_repository); repo_read_index(the_repository);
*o->has_errors |= refresh_index(&the_index, o->flags | flag, NULL, *o->has_errors |= refresh_index(the_repository->index, o->flags | flag, NULL,
NULL, NULL); NULL, NULL);
if (has_racy_timestamp(&the_index)) { if (has_racy_timestamp(the_repository->index)) {
/* /*
* Even if nothing else has changed, updating the file * Even if nothing else has changed, updating the file
* increases the chance that racy timestamps become * increases the chance that racy timestamps become
@ -750,7 +750,7 @@ static int refresh(struct refresh_params *o, unsigned int flag)
* refresh_index() as these are no actual errors. * refresh_index() as these are no actual errors.
* cmd_status() does the same. * cmd_status() does the same.
*/ */
the_index.cache_changed |= SOMETHING_CHANGED; the_repository->index->cache_changed |= SOMETHING_CHANGED;
} }
return 0; return 0;
} }
@ -787,7 +787,7 @@ static int resolve_undo_clear_callback(const struct option *opt UNUSED,
{ {
BUG_ON_OPT_NEG(unset); BUG_ON_OPT_NEG(unset);
BUG_ON_OPT_ARG(arg); BUG_ON_OPT_ARG(arg);
resolve_undo_clear_index(&the_index); resolve_undo_clear_index(the_repository->index);
return 0; return 0;
} }


@ -888,7 +888,7 @@ static enum parse_opt_result unresolve_callback(
*has_errors = do_unresolve(ctx->argc, ctx->argv, *has_errors = do_unresolve(ctx->argc, ctx->argv,
prefix, prefix ? strlen(prefix) : 0); prefix, prefix ? strlen(prefix) : 0);
if (*has_errors) if (*has_errors)
the_index.cache_changed = 0; the_repository->index->cache_changed = 0;


ctx->argv += ctx->argc - 1; ctx->argv += ctx->argc - 1;
ctx->argc = 1; ctx->argc = 1;
@ -909,7 +909,7 @@ static enum parse_opt_result reupdate_callback(
setup_work_tree(); setup_work_tree();
*has_errors = do_reupdate(ctx->argv + 1, prefix); *has_errors = do_reupdate(ctx->argv + 1, prefix);
if (*has_errors) if (*has_errors)
the_index.cache_changed = 0; the_repository->index->cache_changed = 0;


ctx->argv += ctx->argc - 1; ctx->argv += ctx->argc - 1;
ctx->argc = 1; ctx->argc = 1;
@ -1056,7 +1056,7 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
if (entries < 0) if (entries < 0)
die("cache corrupted"); die("cache corrupted");


the_index.updated_skipworktree = 1; the_repository->index->updated_skipworktree = 1;


/* /*
* Custom copy of parse_options() because we want to handle * Custom copy of parse_options() because we want to handle
@ -1111,18 +1111,18 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf; getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
if (preferred_index_format) { if (preferred_index_format) {
if (preferred_index_format < 0) { if (preferred_index_format < 0) {
printf(_("%d\n"), the_index.version); printf(_("%d\n"), the_repository->index->version);
} else if (preferred_index_format < INDEX_FORMAT_LB || } else if (preferred_index_format < INDEX_FORMAT_LB ||
INDEX_FORMAT_UB < preferred_index_format) { INDEX_FORMAT_UB < preferred_index_format) {
die("index-version %d not in range: %d..%d", die("index-version %d not in range: %d..%d",
preferred_index_format, preferred_index_format,
INDEX_FORMAT_LB, INDEX_FORMAT_UB); INDEX_FORMAT_LB, INDEX_FORMAT_UB);
} else { } else {
if (the_index.version != preferred_index_format) if (the_repository->index->version != preferred_index_format)
the_index.cache_changed |= SOMETHING_CHANGED; the_repository->index->cache_changed |= SOMETHING_CHANGED;
report(_("index-version: was %d, set to %d"), report(_("index-version: was %d, set to %d"),
the_index.version, preferred_index_format); the_repository->index->version, preferred_index_format);
the_index.version = preferred_index_format; the_repository->index->version = preferred_index_format;
} }
} }


@ -1159,16 +1159,16 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
warning(_("core.splitIndex is set to false; " warning(_("core.splitIndex is set to false; "
"remove or change it, if you really want to " "remove or change it, if you really want to "
"enable split index")); "enable split index"));
if (the_index.split_index) if (the_repository->index->split_index)
the_index.cache_changed |= SPLIT_INDEX_ORDERED; the_repository->index->cache_changed |= SPLIT_INDEX_ORDERED;
else else
add_split_index(&the_index); add_split_index(the_repository->index);
} else if (!split_index) { } else if (!split_index) {
if (git_config_get_split_index() == 1) if (git_config_get_split_index() == 1)
warning(_("core.splitIndex is set to true; " warning(_("core.splitIndex is set to true; "
"remove or change it, if you really want to " "remove or change it, if you really want to "
"disable split index")); "disable split index"));
remove_split_index(&the_index); remove_split_index(the_repository->index);
} }


prepare_repo_settings(r); prepare_repo_settings(r);
@ -1180,7 +1180,7 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
warning(_("core.untrackedCache is set to true; " warning(_("core.untrackedCache is set to true; "
"remove or change it, if you really want to " "remove or change it, if you really want to "
"disable the untracked cache")); "disable the untracked cache"));
remove_untracked_cache(&the_index); remove_untracked_cache(the_repository->index);
report(_("Untracked cache disabled")); report(_("Untracked cache disabled"));
break; break;
case UC_TEST: case UC_TEST:
@ -1192,7 +1192,7 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
warning(_("core.untrackedCache is set to false; " warning(_("core.untrackedCache is set to false; "
"remove or change it, if you really want to " "remove or change it, if you really want to "
"enable the untracked cache")); "enable the untracked cache"));
add_untracked_cache(&the_index); add_untracked_cache(the_repository->index);
report(_("Untracked cache enabled for '%s'"), get_git_work_tree()); report(_("Untracked cache enabled for '%s'"), get_git_work_tree());
break; break;
default: default:
@ -1222,7 +1222,7 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
"set it if you really want to " "set it if you really want to "
"enable fsmonitor")); "enable fsmonitor"));
} }
add_fsmonitor(&the_index); add_fsmonitor(the_repository->index);
report(_("fsmonitor enabled")); report(_("fsmonitor enabled"));
} else if (!fsmonitor) { } else if (!fsmonitor) {
enum fsmonitor_mode fsm_mode = fsm_settings__get_mode(r); enum fsmonitor_mode fsm_mode = fsm_settings__get_mode(r);
@ -1230,17 +1230,17 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
warning(_("core.fsmonitor is set; " warning(_("core.fsmonitor is set; "
"remove it if you really want to " "remove it if you really want to "
"disable fsmonitor")); "disable fsmonitor"));
remove_fsmonitor(&the_index); remove_fsmonitor(the_repository->index);
report(_("fsmonitor disabled")); report(_("fsmonitor disabled"));
} }


if (the_index.cache_changed || force_write) { if (the_repository->index->cache_changed || force_write) {
if (newfd < 0) { if (newfd < 0) {
if (refresh_args.flags & REFRESH_QUIET) if (refresh_args.flags & REFRESH_QUIET)
exit(128); exit(128);
unable_to_lock_die(get_index_file(), lock_error); unable_to_lock_die(get_index_file(), lock_error);
} }
if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
die("Unable to write new index file"); die("Unable to write new index file");
} }



6
builtin/write-tree.c
View File

@ -3,7 +3,7 @@
* *
* Copyright (C) Linus Torvalds, 2005 * Copyright (C) Linus Torvalds, 2005
*/ */
#define USE_THE_INDEX_VARIABLE
#include "builtin.h" #include "builtin.h"
#include "config.h" #include "config.h"
#include "environment.h" #include "environment.h"
@ -44,8 +44,8 @@ int cmd_write_tree(int argc, const char **argv, const char *cmd_prefix)
prepare_repo_settings(the_repository); prepare_repo_settings(the_repository);
the_repository->settings.command_requires_full_index = 0; the_repository->settings.command_requires_full_index = 0;


ret = write_index_as_tree(&oid, &the_index, get_index_file(), flags, ret = write_index_as_tree(&oid, the_repository->index, get_index_file(),
tree_prefix); flags, tree_prefix);
switch (ret) { switch (ret) {
case 0: case 0:
printf("%s\n", oid_to_hex(&oid)); printf("%s\n", oid_to_hex(&oid));