2005-04-07 22:16:10 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-09-06 19:53:56 +00:00
|
|
|
|
2022-11-19 13:07:38 +00:00
|
|
|
#define USE_THE_INDEX_VARIABLE
|
2005-04-07 22:13:13 +00:00
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2014-10-01 10:28:42 +00:00
|
|
|
#include "lockfile.h"
|
2005-09-05 06:04:48 +00:00
|
|
|
#include "object.h"
|
|
|
|
#include "tree.h"
|
2006-05-29 19:18:00 +00:00
|
|
|
#include "tree-walk.h"
|
2006-04-25 04:18:58 +00:00
|
|
|
#include "cache-tree.h"
|
2006-07-30 18:25:18 +00:00
|
|
|
#include "unpack-trees.h"
|
2006-12-05 00:00:46 +00:00
|
|
|
#include "dir.h"
|
2006-05-23 12:15:32 +00:00
|
|
|
#include "builtin.h"
|
2009-06-26 05:14:10 +00:00
|
|
|
#include "parse-options.h"
|
2009-12-25 08:30:51 +00:00
|
|
|
#include "resolve-undo.h"
|
2017-03-14 21:46:42 +00:00
|
|
|
#include "submodule.h"
|
|
|
|
#include "submodule-config.h"
|
2005-09-05 06:04:48 +00:00
|
|
|
|
2007-08-10 05:21:29 +00:00
|
|
|
static int nr_trees;
|
2010-09-10 13:28:59 +00:00
|
|
|
static int read_empty;
|
2008-03-14 05:07:18 +00:00
|
|
|
static struct tree *trees[MAX_UNPACK_TREES];
|
2005-09-05 06:04:48 +00:00
|
|
|
|
2017-05-06 22:10:30 +00:00
|
|
|
static int list_tree(struct object_id *oid)
|
2005-09-05 06:04:48 +00:00
|
|
|
{
|
2007-08-10 05:21:29 +00:00
|
|
|
struct tree *tree;
|
|
|
|
|
2008-03-14 05:07:18 +00:00
|
|
|
if (nr_trees >= MAX_UNPACK_TREES)
|
|
|
|
die("I cannot read more than %d trees", MAX_UNPACK_TREES);
|
2017-05-06 22:10:37 +00:00
|
|
|
tree = parse_tree_indirect(oid);
|
2005-09-05 06:04:48 +00:00
|
|
|
if (!tree)
|
|
|
|
return -1;
|
2007-08-10 05:21:29 +00:00
|
|
|
trees[nr_trees++] = tree;
|
2005-09-05 06:04:48 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-26 05:14:10 +00:00
|
|
|
static const char * const read_tree_usage[] = {
|
2022-10-13 15:39:02 +00:00
|
|
|
N_("git read-tree [(-m [--trivial] [--aggressive] | --reset | --prefix=<prefix>)\n"
|
2022-10-13 15:39:15 +00:00
|
|
|
" [-u | -i]] [--index-output=<file>] [--no-sparse-checkout]\n"
|
2022-10-13 15:39:02 +00:00
|
|
|
" (--empty | <tree-ish1> [<tree-ish2> [<tree-ish3>]])"),
|
2009-06-26 05:14:10 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static int index_output_cb(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
|
|
|
{
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
2009-06-26 05:14:10 +00:00
|
|
|
set_alternate_index_output(arg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int exclude_per_directory_cb(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
|
|
|
{
|
|
|
|
struct unpack_trees_options *opts;
|
|
|
|
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
|
|
|
|
2009-06-26 05:14:10 +00:00
|
|
|
opts = (struct unpack_trees_options *)opt->value;
|
|
|
|
|
read-tree, merge-recursive: overwrite ignored files by default
This fixes a long-standing patchwork of ignored files handling in
read-tree and merge-recursive, called out and suggested by Junio long
ago. Quoting from commit dcf0c16ef1 ("core.excludesfile clean-up"
2007-11-16):
git-read-tree takes --exclude-per-directory=<gitignore>,
not because the flexibility was needed. Again, this was
because the option predates the standardization of the ignore
files.
...
On the other hand, I think it makes perfect sense to fix
git-read-tree, git-merge-recursive and git-clean to follow the
same rule as other commands. I do not think of a valid use case
to give an exclude-per-directory that is nonstandard to
read-tree command, outside a "negative" test in the t1004 test
script.
This patch is the first step to untangle this mess.
The next step would be to teach read-tree, merge-recursive and
clean (in C) to use setup_standard_excludes().
History shows each of these were partially or fully fixed:
* clean was taught the new trick in 1617adc7a0 ("Teach git clean to
use setup_standard_excludes()", 2007-11-14).
* read-tree was primarily used by checkout & merge scripts. checkout
and merge later became builtins and were both fixed to use the new
setup_standard_excludes() handling in fc001b526c ("checkout,merge:
loosen overwriting untracked file check based on info/exclude",
2011-11-27). So the primary users were fixed, though read-tree
itself was not.
* merge-recursive has now been replaced as the default merge backend
by merge-ort. merge-ort fixed this by using
setup_standard_excludes() starting early in its implementation; see
commit 6681ce5cf6 ("merge-ort: add implementation of checkout()",
2020-12-13), largely due to its design depending on checkout() and
thus being influenced by the checkout code. However,
merge-recursive itself was not fixed here, in part because its
design meant it had difficulty differentiating between untracked
files, ignored files, leftover tracked files that haven't been
removed yet due to order of processing files, and files written by
itself due to collisions).
Make the conversion more complete by now handling read-tree and
handling at least the unpack_trees() portion of merge-recursive. While
merge-recursive is on its way out, fixing the unpack_trees() portion is
easy and facilitates some of the later changes in this series. Note
that fixing read-tree makes the --exclude-per-directory option to
read-tree useless, so we remove it from the documentation (though we
continue to accept it if passed).
The read-tree changes happen to fix a bug in t1013.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-09-27 16:33:40 +00:00
|
|
|
if (!opts->update)
|
|
|
|
die("--exclude-per-directory is meaningless unless -u");
|
|
|
|
if (strcmp(arg, ".gitignore"))
|
|
|
|
die("--exclude-per-directory argument must be .gitignore");
|
2009-06-26 05:14:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-21 02:49:16 +00:00
|
|
|
|
2013-06-02 15:46:55 +00:00
|
|
|
static void debug_stage(const char *label, const struct cache_entry *ce,
|
2009-09-14 09:22:00 +00:00
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
printf("%s ", label);
|
|
|
|
if (!ce)
|
|
|
|
printf("(missing)\n");
|
|
|
|
else if (ce == o->df_conflict_entry)
|
|
|
|
printf("(conflict)\n");
|
|
|
|
else
|
|
|
|
printf("%06o #%d %s %.8s\n",
|
|
|
|
ce->ce_mode, ce_stage(ce), ce->name,
|
2016-09-05 20:07:52 +00:00
|
|
|
oid_to_hex(&ce->oid));
|
2009-09-14 09:22:00 +00:00
|
|
|
}
|
|
|
|
|
2013-06-02 15:46:56 +00:00
|
|
|
static int debug_merge(const struct cache_entry * const *stages,
|
|
|
|
struct unpack_trees_options *o)
|
2009-09-14 09:22:00 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
printf("* %d-way merge\n", o->merge_size);
|
|
|
|
debug_stage("index", stages[0], o);
|
|
|
|
for (i = 1; i <= o->merge_size; i++) {
|
|
|
|
char buf[24];
|
2015-09-24 21:06:08 +00:00
|
|
|
xsnprintf(buf, sizeof(buf), "ent#%d", i);
|
2009-09-14 09:22:00 +00:00
|
|
|
debug_stage(buf, stages[i], o);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-01 00:30:47 +00:00
|
|
|
static int git_read_tree_config(const char *var, const char *value, void *cb)
|
2017-03-14 21:46:42 +00:00
|
|
|
{
|
2017-06-01 00:30:47 +00:00
|
|
|
if (!strcmp(var, "submodule.recurse"))
|
|
|
|
return git_default_submodule_config(var, value, cb);
|
2017-03-14 21:46:42 +00:00
|
|
|
|
2017-06-01 00:30:47 +00:00
|
|
|
return git_default_config(var, value, cb);
|
2017-03-14 21:46:42 +00:00
|
|
|
}
|
|
|
|
|
2019-05-09 21:27:24 +00:00
|
|
|
int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
|
2005-04-07 22:13:13 +00:00
|
|
|
{
|
2014-06-13 12:19:23 +00:00
|
|
|
int i, stage = 0;
|
2017-05-06 22:10:30 +00:00
|
|
|
struct object_id oid;
|
2008-03-14 05:07:18 +00:00
|
|
|
struct tree_desc t[MAX_UNPACK_TREES];
|
2006-07-30 18:25:18 +00:00
|
|
|
struct unpack_trees_options opts;
|
2009-06-26 05:14:10 +00:00
|
|
|
int prefix_set = 0;
|
lock_file: move static locks into functions
Placing `struct lock_file`s on the stack used to be a bad idea, because
the temp- and lockfile-machinery would keep a pointer into the struct.
But after 076aa2cbd (tempfile: auto-allocate tempfiles on heap,
2017-09-05), we can safely have lockfiles on the stack. (This applies
even if a user returns early, leaving a locked lock behind.)
Each of these `struct lock_file`s is used from within a single function.
Move them into the respective functions to make the scope clearer and
drop the staticness.
For good measure, I have inspected these sites and come to believe that
they always release the lock, with the possible exception of bailing out
using `die()` or `exit()` or by returning from a `cmd_foo()`.
As pointed out by Jeff King, it would be bad if someone held on to a
`struct lock_file *` for some reason. After some grepping, I agree with
his findings: no-one appears to be doing that.
After this commit, the remaining occurrences of "static struct
lock_file" are locks that are used from within different functions. That
is, they need to remain static. (Short of more intrusive changes like
passing around pointers to non-static locks.)
Signed-off-by: Martin Ågren <martin.agren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-05-09 20:55:39 +00:00
|
|
|
struct lock_file lock_file = LOCK_INIT;
|
2009-06-26 05:14:10 +00:00
|
|
|
const struct option read_tree_options[] = {
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
OPT_CALLBACK_F(0, "index-output", NULL, N_("file"),
|
2012-08-20 12:32:34 +00:00
|
|
|
N_("write resulting index to <file>"),
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
PARSE_OPT_NONEG, index_output_cb),
|
2017-01-10 01:45:39 +00:00
|
|
|
OPT_BOOL(0, "empty", &read_empty,
|
|
|
|
N_("only empty the index")),
|
2012-08-20 12:32:34 +00:00
|
|
|
OPT__VERBOSE(&opts.verbose_update, N_("be verbose")),
|
|
|
|
OPT_GROUP(N_("Merging")),
|
2017-01-10 01:45:39 +00:00
|
|
|
OPT_BOOL('m', NULL, &opts.merge,
|
|
|
|
N_("perform a merge in addition to a read")),
|
|
|
|
OPT_BOOL(0, "trivial", &opts.trivial_merges_only,
|
|
|
|
N_("3-way merge if no file level merging required")),
|
|
|
|
OPT_BOOL(0, "aggressive", &opts.aggressive,
|
|
|
|
N_("3-way merge in presence of adds and removes")),
|
|
|
|
OPT_BOOL(0, "reset", &opts.reset,
|
|
|
|
N_("same as -m, but discard unmerged entries")),
|
2012-08-20 12:32:34 +00:00
|
|
|
{ OPTION_STRING, 0, "prefix", &opts.prefix, N_("<subdirectory>/"),
|
|
|
|
N_("read the tree into the index under <subdirectory>/"),
|
2018-08-02 19:18:14 +00:00
|
|
|
PARSE_OPT_NONEG },
|
2017-01-10 01:45:39 +00:00
|
|
|
OPT_BOOL('u', NULL, &opts.update,
|
|
|
|
N_("update working tree with merge result")),
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
OPT_CALLBACK_F(0, "exclude-per-directory", &opts,
|
2012-08-20 12:32:34 +00:00
|
|
|
N_("gitignore"),
|
|
|
|
N_("allow explicitly ignored files to be overwritten"),
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
PARSE_OPT_NONEG, exclude_per_directory_cb),
|
2017-01-10 01:45:39 +00:00
|
|
|
OPT_BOOL('i', NULL, &opts.index_only,
|
|
|
|
N_("don't check the working tree after merging")),
|
2012-08-20 12:32:34 +00:00
|
|
|
OPT__DRY_RUN(&opts.dry_run, N_("don't update the index or the work tree")),
|
2017-01-10 01:45:39 +00:00
|
|
|
OPT_BOOL(0, "no-sparse-checkout", &opts.skip_sparse_checkout,
|
|
|
|
N_("skip applying sparse checkout filter")),
|
|
|
|
OPT_BOOL(0, "debug-unpack", &opts.debug_unpack,
|
|
|
|
N_("debug unpack-trees")),
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
OPT_CALLBACK_F(0, "recurse-submodules", NULL,
|
2017-03-14 21:46:42 +00:00
|
|
|
"checkout", "control recursive updating of submodules",
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater),
|
2019-03-22 09:31:37 +00:00
|
|
|
OPT__QUIET(&opts.quiet, N_("suppress feedback messages")),
|
2009-06-26 05:14:10 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
2005-04-21 17:55:18 +00:00
|
|
|
|
2006-07-30 18:25:18 +00:00
|
|
|
memset(&opts, 0, sizeof(opts));
|
|
|
|
opts.head_idx = -1;
|
2008-03-07 02:12:28 +00:00
|
|
|
opts.src_index = &the_index;
|
|
|
|
opts.dst_index = &the_index;
|
2006-07-08 18:34:02 +00:00
|
|
|
|
2017-06-01 00:30:47 +00:00
|
|
|
git_config(git_read_tree_config, NULL);
|
2005-11-26 08:50:02 +00:00
|
|
|
|
2019-05-09 21:27:24 +00:00
|
|
|
argc = parse_options(argc, argv, cmd_prefix, read_tree_options,
|
2009-06-26 05:14:10 +00:00
|
|
|
read_tree_usage, 0);
|
2005-04-09 19:11:25 +00:00
|
|
|
|
2009-06-26 05:14:10 +00:00
|
|
|
prefix_set = opts.prefix ? 1 : 0;
|
|
|
|
if (1 < opts.merge + opts.reset + prefix_set)
|
|
|
|
die("Which one? -m, --reset, or --prefix?");
|
2009-08-17 15:35:44 +00:00
|
|
|
|
2022-03-01 20:24:26 +00:00
|
|
|
/* Prefix should not start with a directory separator */
|
|
|
|
if (opts.prefix && opts.prefix[0] == '/')
|
|
|
|
die("Invalid prefix, prefix cannot start with '/'");
|
|
|
|
|
2021-09-27 16:33:44 +00:00
|
|
|
if (opts.reset)
|
|
|
|
opts.reset = UNPACK_RESET_OVERWRITE_UNTRACKED;
|
|
|
|
|
2022-03-01 20:24:28 +00:00
|
|
|
prepare_repo_settings(the_repository);
|
|
|
|
the_repository->settings.command_requires_full_index = 0;
|
|
|
|
|
2022-11-19 13:07:38 +00:00
|
|
|
repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
|
2022-03-01 20:24:28 +00:00
|
|
|
|
2014-06-13 12:19:48 +00:00
|
|
|
/*
|
|
|
|
* NEEDSWORK
|
|
|
|
*
|
|
|
|
* The old index should be read anyway even if we're going to
|
|
|
|
* destroy all index entries because we still need to preserve
|
|
|
|
* certain information such as index version or split-index
|
|
|
|
* mode.
|
|
|
|
*/
|
|
|
|
|
2009-08-17 15:35:44 +00:00
|
|
|
if (opts.reset || opts.merge || opts.prefix) {
|
2022-11-19 13:07:30 +00:00
|
|
|
if (repo_read_index_unmerged(the_repository) && (opts.prefix || opts.merge))
|
2019-11-21 22:04:46 +00:00
|
|
|
die(_("You need to resolve your current index first"));
|
2009-08-17 15:35:44 +00:00
|
|
|
stage = opts.merge = 1;
|
|
|
|
}
|
2022-11-19 13:07:33 +00:00
|
|
|
resolve_undo_clear_index(&the_index);
|
2009-06-26 05:14:10 +00:00
|
|
|
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
2005-09-11 00:46:27 +00:00
|
|
|
|
2017-05-06 22:10:30 +00:00
|
|
|
if (get_oid(arg, &oid))
|
2006-05-08 21:43:38 +00:00
|
|
|
die("Not a valid object name %s", arg);
|
2017-05-06 22:10:30 +00:00
|
|
|
if (list_tree(&oid) < 0)
|
2005-04-13 09:28:48 +00:00
|
|
|
die("failed to unpack tree object %s", arg);
|
2005-04-16 05:53:45 +00:00
|
|
|
stage++;
|
2005-04-09 19:11:25 +00:00
|
|
|
}
|
2017-05-11 04:31:54 +00:00
|
|
|
if (!nr_trees && !read_empty && !opts.merge)
|
2010-09-10 13:28:59 +00:00
|
|
|
warning("read-tree: emptying the index with no arguments is deprecated; use --empty");
|
|
|
|
else if (nr_trees > 0 && read_empty)
|
|
|
|
die("passing trees as arguments contradicts --empty");
|
|
|
|
|
2009-06-26 05:14:10 +00:00
|
|
|
if (1 < opts.index_only + opts.update)
|
|
|
|
die("-u and -i at the same time makes no sense");
|
2013-10-16 17:26:39 +00:00
|
|
|
if ((opts.update || opts.index_only) && !opts.merge)
|
2009-06-26 05:14:09 +00:00
|
|
|
die("%s is meaningless without -m, --reset, or --prefix",
|
|
|
|
opts.update ? "-u" : "-i");
|
2021-09-27 16:33:41 +00:00
|
|
|
if (opts.update && !opts.reset)
|
|
|
|
opts.preserve_ignored = 0;
|
|
|
|
/* otherwise, opts.preserve_ignored is irrelevant */
|
2008-08-28 13:03:22 +00:00
|
|
|
if (opts.merge && !opts.index_only)
|
|
|
|
setup_work_tree();
|
2005-10-02 07:50:16 +00:00
|
|
|
|
2022-03-01 20:24:29 +00:00
|
|
|
if (opts.skip_sparse_checkout)
|
2022-03-01 20:24:28 +00:00
|
|
|
ensure_full_index(&the_index);
|
|
|
|
|
2006-07-30 18:25:18 +00:00
|
|
|
if (opts.merge) {
|
2005-09-05 06:04:48 +00:00
|
|
|
switch (stage - 1) {
|
2017-05-11 12:06:33 +00:00
|
|
|
case 0:
|
|
|
|
die("you must specify at least one tree to merge");
|
|
|
|
break;
|
2005-09-05 06:04:48 +00:00
|
|
|
case 1:
|
2006-07-30 18:25:18 +00:00
|
|
|
opts.fn = opts.prefix ? bind_merge : oneway_merge;
|
2005-09-05 06:04:48 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2006-07-30 18:25:18 +00:00
|
|
|
opts.fn = twoway_merge;
|
2022-11-19 13:07:30 +00:00
|
|
|
opts.initial_checkout = is_index_unborn(&the_index);
|
2005-09-05 06:04:48 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
default:
|
2006-07-30 18:25:18 +00:00
|
|
|
opts.fn = threeway_merge;
|
2005-09-05 06:04:48 +00:00
|
|
|
break;
|
2005-06-11 01:36:08 +00:00
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
|
|
|
|
if (stage - 1 >= 3)
|
2006-07-30 18:25:18 +00:00
|
|
|
opts.head_idx = stage - 2;
|
2005-09-05 06:04:48 +00:00
|
|
|
else
|
2006-07-30 18:25:18 +00:00
|
|
|
opts.head_idx = 1;
|
2005-09-05 06:04:48 +00:00
|
|
|
}
|
|
|
|
|
2009-09-14 09:22:00 +00:00
|
|
|
if (opts.debug_unpack)
|
|
|
|
opts.fn = debug_merge;
|
|
|
|
|
2022-11-10 19:06:04 +00:00
|
|
|
/* If we're going to prime_cache_tree later, skip cache tree update */
|
|
|
|
if (nr_trees == 1 && !opts.prefix)
|
|
|
|
opts.skip_cache_tree_update = 1;
|
|
|
|
|
2022-11-19 13:07:34 +00:00
|
|
|
cache_tree_free(&the_index.cache_tree);
|
2007-08-10 05:21:29 +00:00
|
|
|
for (i = 0; i < nr_trees; i++) {
|
|
|
|
struct tree *tree = trees[i];
|
|
|
|
parse_tree(tree);
|
|
|
|
init_tree_desc(t+i, tree->buffer, tree->size);
|
|
|
|
}
|
2008-02-07 16:39:48 +00:00
|
|
|
if (unpack_trees(nr_trees, t, &opts))
|
|
|
|
return 128;
|
2006-04-27 08:33:07 +00:00
|
|
|
|
2011-05-25 20:10:41 +00:00
|
|
|
if (opts.debug_unpack || opts.dry_run)
|
2009-09-14 09:22:00 +00:00
|
|
|
return 0; /* do not write the index out */
|
|
|
|
|
2006-04-27 08:33:07 +00:00
|
|
|
/*
|
|
|
|
* When reading only one tree (either the most basic form,
|
|
|
|
* "-m ent" or "--reset ent" form), we can obtain a fully
|
|
|
|
* valid cache-tree because the index must match exactly
|
|
|
|
* what came from the tree.
|
|
|
|
*/
|
2009-04-20 10:58:17 +00:00
|
|
|
if (nr_trees == 1 && !opts.prefix)
|
2018-11-10 05:49:02 +00:00
|
|
|
prime_cache_tree(the_repository,
|
|
|
|
the_repository->index,
|
|
|
|
trees[0]);
|
2006-04-27 08:33:07 +00:00
|
|
|
|
2014-06-13 12:19:23 +00:00
|
|
|
if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
|
2005-04-13 09:28:48 +00:00
|
|
|
die("unable to write new index file");
|
2005-04-11 22:39:26 +00:00
|
|
|
return 0;
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|