A subsequent commit will change the internals of several functions and
arrange them in a more logical manner. Move these functions to their
final positions so that the diff is smaller.
Signed-off-by: Glen Choo <chooglen@xxxxxxxxxx>
---
builtin/submodule--helper.c | 228 ++++++++++++++++++------------------
1 file changed, 114 insertions(+), 114 deletions(-)
diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
index 5635f0c48b..0ab8f9d49f 100644
--- a/builtin/submodule--helper.c
+++ b/builtin/submodule--helper.c
@@ -2451,120 +2451,6 @@ static void update_submodule(struct update_clone_data *ucd)
ucd->sub->path);
}
-static int update_submodules(struct submodule_update_clone *suc)
-{
- int i;
-
- run_processes_parallel_tr2(suc->max_jobs, update_clone_get_next_task,
- update_clone_start_failure,
- update_clone_task_finished, suc, "submodule",
- "parallel/update");
-
- /*
- * We saved the output and put it out all at once now.
- * That means:
- * - the listener does not have to interleave their (checkout)
- * work with our fetching. The writes involved in a
- * checkout involve more straightforward sequential I/O.
- * - the listener can avoid doing any work if fetching failed.
- */
- if (suc->quickstop)
- return 1;
-
- for (i = 0; i < suc->update_clone_nr; i++)
- update_submodule(&suc->update_clone[i]);
-
- return 0;
-}
-
-static int update_clone(int argc, const char **argv, const char *prefix)
-{
- const char *update = NULL;
- struct pathspec pathspec;
- struct submodule_update_clone opt = SUBMODULE_UPDATE_CLONE_INIT;
-
- struct option module_update_clone_options[] = {
- OPT_BOOL(0, "init", &opt.init,
- N_("initialize uninitialized submodules before update")),
- OPT_STRING(0, "prefix", &prefix,
- N_("path"),
- N_("path into the working tree")),
- OPT_STRING(0, "recursive-prefix", &opt.recursive_prefix,
- N_("path"),
- N_("path into the working tree, across nested "
- "submodule boundaries")),
- OPT_STRING(0, "update", &update,
- N_("string"),
- N_("rebase, merge, checkout or none")),
- OPT_STRING_LIST(0, "reference", &opt.references, N_("repo"),
- N_("reference repository")),
- OPT_BOOL(0, "dissociate", &opt.dissociate,
- N_("use --reference only while cloning")),
- OPT_STRING(0, "depth", &opt.depth, "<depth>",
- N_("create a shallow clone truncated to the "
- "specified number of revisions")),
- OPT_INTEGER('j', "jobs", &opt.max_jobs,
- N_("parallel jobs")),
- OPT_BOOL(0, "recommend-shallow", &opt.recommend_shallow,
- N_("whether the initial clone should follow the shallow recommendation")),
- OPT__QUIET(&opt.quiet, N_("don't print cloning progress")),
- OPT_BOOL(0, "progress", &opt.progress,
- N_("force cloning progress")),
- OPT_BOOL(0, "require-init", &opt.require_init,
- N_("disallow cloning into non-empty directory")),
- OPT_BOOL(0, "single-branch", &opt.single_branch,
- N_("clone only one branch, HEAD or --branch")),
- OPT_END()
- };
-
- const char *const git_submodule_helper_usage[] = {
- N_("git submodule--helper update-clone [--prefix=<path>] [<path>...]"),
- NULL
- };
- opt.prefix = prefix;
-
- update_clone_config_from_gitmodules(&opt.max_jobs);
- git_config(git_update_clone_config, &opt.max_jobs);
-
- argc = parse_options(argc, argv, prefix, module_update_clone_options,
- git_submodule_helper_usage, 0);
-
- if (update)
- if (parse_submodule_update_strategy(update, &opt.update) < 0)
- die(_("bad value for update parameter"));
-
- if (module_list_compute(argc, argv, prefix, &pathspec, &opt.list) < 0)
- return 1;
-
- if (pathspec.nr)
- opt.warn_if_uninitialized = 1;
-
- if (opt.init) {
- struct module_list list = MODULE_LIST_INIT;
- struct init_cb info = INIT_CB_INIT;
-
- if (module_list_compute(argc, argv, opt.prefix,
- &pathspec, &list) < 0)
- return 1;
-
- /*
- * If there are no path args and submodule.active is set then,
- * by default, only initialize 'active' modules.
- */
- if (!argc && git_config_get_value_multi("submodule.active"))
- module_list_active(&list);
-
- info.prefix = opt.prefix;
- info.superprefix = opt.recursive_prefix;
- if (opt.quiet)
- info.flags |= OPT_QUIET;
-
- for_each_listed_submodule(&list, init_submodule_cb, &info);
- }
-
- return update_submodules(&opt);
-}
-
/*
* NEEDSWORK: Use a forward declaration to avoid moving
* run_update_procedure() (which will be removed soon).
@@ -3021,6 +2907,120 @@ static int update_submodule2(struct update_data *update_data)
return 3;
}
+static int update_submodules(struct submodule_update_clone *suc)
+{
+ int i;
+
+ run_processes_parallel_tr2(suc->max_jobs, update_clone_get_next_task,
+ update_clone_start_failure,
+ update_clone_task_finished, suc, "submodule",
+ "parallel/update");
+
+ /*
+ * We saved the output and put it out all at once now.
+ * That means:
+ * - the listener does not have to interleave their (checkout)
+ * work with our fetching. The writes involved in a
+ * checkout involve more straightforward sequential I/O.
+ * - the listener can avoid doing any work if fetching failed.
+ */
+ if (suc->quickstop)
+ return 1;
+
+ for (i = 0; i < suc->update_clone_nr; i++)
+ update_submodule(&suc->update_clone[i]);
+
+ return 0;
+}
+
+static int update_clone(int argc, const char **argv, const char *prefix)
+{
+ const char *update = NULL;
+ struct pathspec pathspec;
+ struct submodule_update_clone opt = SUBMODULE_UPDATE_CLONE_INIT;
+
+ struct option module_update_clone_options[] = {
+ OPT_BOOL(0, "init", &opt.init,
+ N_("initialize uninitialized submodules before update")),
+ OPT_STRING(0, "prefix", &prefix,
+ N_("path"),
+ N_("path into the working tree")),
+ OPT_STRING(0, "recursive-prefix", &opt.recursive_prefix,
+ N_("path"),
+ N_("path into the working tree, across nested "
+ "submodule boundaries")),
+ OPT_STRING(0, "update", &update,
+ N_("string"),
+ N_("rebase, merge, checkout or none")),
+ OPT_STRING_LIST(0, "reference", &opt.references, N_("repo"),
+ N_("reference repository")),
+ OPT_BOOL(0, "dissociate", &opt.dissociate,
+ N_("use --reference only while cloning")),
+ OPT_STRING(0, "depth", &opt.depth, "<depth>",
+ N_("create a shallow clone truncated to the "
+ "specified number of revisions")),
+ OPT_INTEGER('j', "jobs", &opt.max_jobs,
+ N_("parallel jobs")),
+ OPT_BOOL(0, "recommend-shallow", &opt.recommend_shallow,
+ N_("whether the initial clone should follow the shallow recommendation")),
+ OPT__QUIET(&opt.quiet, N_("don't print cloning progress")),
+ OPT_BOOL(0, "progress", &opt.progress,
+ N_("force cloning progress")),
+ OPT_BOOL(0, "require-init", &opt.require_init,
+ N_("disallow cloning into non-empty directory")),
+ OPT_BOOL(0, "single-branch", &opt.single_branch,
+ N_("clone only one branch, HEAD or --branch")),
+ OPT_END()
+ };
+
+ const char *const git_submodule_helper_usage[] = {
+ N_("git submodule--helper update-clone [--prefix=<path>] [<path>...]"),
+ NULL
+ };
+ opt.prefix = prefix;
+
+ update_clone_config_from_gitmodules(&opt.max_jobs);
+ git_config(git_update_clone_config, &opt.max_jobs);
+
+ argc = parse_options(argc, argv, prefix, module_update_clone_options,
+ git_submodule_helper_usage, 0);
+
+ if (update)
+ if (parse_submodule_update_strategy(update, &opt.update) < 0)
+ die(_("bad value for update parameter"));
+
+ if (module_list_compute(argc, argv, prefix, &pathspec, &opt.list) < 0)
+ return 1;
+
+ if (pathspec.nr)
+ opt.warn_if_uninitialized = 1;
+
+ if (opt.init) {
+ struct module_list list = MODULE_LIST_INIT;
+ struct init_cb info = INIT_CB_INIT;
+
+ if (module_list_compute(argc, argv, opt.prefix,
+ &pathspec, &list) < 0)
+ return 1;
+
+ /*
+ * If there are no path args and submodule.active is set then,
+ * by default, only initialize 'active' modules.
+ */
+ if (!argc && git_config_get_value_multi("submodule.active"))
+ module_list_active(&list);
+
+ info.prefix = opt.prefix;
+ info.superprefix = opt.recursive_prefix;
+ if (opt.quiet)
+ info.flags |= OPT_QUIET;
+
+ for_each_listed_submodule(&list, init_submodule_cb, &info);
+ }
+
+ return update_submodules(&opt);
+}
+
struct add_data {
const char *prefix;
const char *branch;
--
2.33.GIT
