opensourcemirror
/
git
mirror of https://github.com/git/git.git
1
0
Fork 0
Code Issues Releases Wiki Activity

use child_process members "args" and "env" directly 

Build argument list and environment of child processes by using
struct child_process and populating its members "args" and "env"
directly instead of maintaining separate strvecs and letting
run_command_v_opt() and friends populate these members.  This is
simpler, shorter and slightly more efficient.

Signed-off-by: René Scharfe <l.s.r@web.de>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
This commit is contained in:
René Scharfe 2022-10-30 12:51:14 +01:00 committed by Taylor Blau
parent 4120294cbf
commit 0e90673957
13 changed files with 185 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
add-interactive.c
View File

@ -997,18 +997,17 @@ static int run_diff(struct add_i_state *s, const struct pathspec *ps,
count = list_and_choose(s, files, opts);
opts->flags = 0;
if (count > 0) {
struct strvec args = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
strvec_pushl(&args, "git", "diff", "-p", "--cached",
strvec_pushl(&cmd.args, "git", "diff", "-p", "--cached",
oid_to_hex(!is_initial ? &oid :
s->r->hash_algo->empty_tree),
"--", NULL);
for (i = 0; i < files->items.nr; i++)
if (files->selected[i])
strvec_push(&args,
strvec_push(&cmd.args,
files->items.items[i].string);
res = run_command_v_opt(args.v, 0);
strvec_clear(&args);
res = run_command(&cmd);
}
putchar('\n');

19
builtin/add.c
View File

@ -240,8 +240,8 @@ static int refresh(int verbose, const struct pathspec *pathspec)
int run_add_interactive(const char *revision, const char *patch_mode,
const struct pathspec *pathspec)
{
int status, i;
struct strvec argv = STRVEC_INIT;
int i;
struct child_process cmd = CHILD_PROCESS_INIT;
int use_builtin_add_i =
git_env_bool("GIT_TEST_ADD_I_USE_BUILTIN", -1);
@ -272,19 +272,18 @@ int run_add_interactive(const char *revision, const char *patch_mode,
return !!run_add_p(the_repository, mode, revision, pathspec);
}
strvec_push(&argv, "add--interactive");
strvec_push(&cmd.args, "add--interactive");
if (patch_mode)
strvec_push(&argv, patch_mode);
strvec_push(&cmd.args, patch_mode);
if (revision)
strvec_push(&argv, revision);
strvec_push(&argv, "--");
strvec_push(&cmd.args, revision);
strvec_push(&cmd.args, "--");
for (i = 0; i < pathspec->nr; i++)
/* pass original pathspec, to be re-parsed */
strvec_push(&argv, pathspec->items[i].original);
strvec_push(&cmd.args, pathspec->items[i].original);
status = run_command_v_opt(argv.v, RUN_GIT_CMD);
strvec_clear(&argv);
return status;
cmd.git_cmd = 1;
return run_command(&cmd);
}
int interactive_add(const char **argv, const char *prefix, int patch)

35
builtin/bisect--helper.c
View File

@ -220,18 +220,17 @@ static int bisect_reset(const char *commit)
}
if (!ref_exists("BISECT_HEAD")) {
struct strvec argv = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
strvec_pushl(&argv, "checkout", branch.buf, "--", NULL);
if (run_command_v_opt(argv.v, RUN_GIT_CMD)) {
cmd.git_cmd = 1;
strvec_pushl(&cmd.args, "checkout", branch.buf, "--", NULL);
if (run_command(&cmd)) {
error(_("could not check out original"
" HEAD '%s'. Try 'git bisect"
" reset <commit>'."), branch.buf);
strbuf_release(&branch);
strvec_clear(&argv);
return -1;
}
strvec_clear(&argv);
}
strbuf_release(&branch);
@ -1098,40 +1097,38 @@ static enum bisect_error bisect_skip(struct bisect_terms *terms, const char **ar
static int bisect_visualize(struct bisect_terms *terms, const char **argv, int argc)
{
struct strvec args = STRVEC_INIT;
int flags = RUN_COMMAND_NO_STDIN, res = 0;
struct child_process cmd = CHILD_PROCESS_INIT;
struct strbuf sb = STRBUF_INIT;
if (bisect_next_check(terms, NULL) != 0)
return BISECT_FAILED;
cmd.no_stdin = 1;
if (!argc) {
if ((getenv("DISPLAY") || getenv("SESSIONNAME") || getenv("MSYSTEM") ||
getenv("SECURITYSESSIONID")) && exists_in_PATH("gitk")) {
strvec_push(&args, "gitk");
strvec_push(&cmd.args, "gitk");
} else {
strvec_push(&args, "log");
flags |= RUN_GIT_CMD;
strvec_push(&cmd.args, "log");
cmd.git_cmd = 1;
}
} else {
if (argv[0][0] == '-') {
strvec_push(&args, "log");
flags |= RUN_GIT_CMD;
strvec_push(&cmd.args, "log");
cmd.git_cmd = 1;
} else if (strcmp(argv[0], "tig") && !starts_with(argv[0], "git"))
flags |= RUN_GIT_CMD;
cmd.git_cmd = 1;
strvec_pushv(&args, argv);
strvec_pushv(&cmd.args, argv);
}
strvec_pushl(&args, "--bisect", "--", NULL);
strvec_pushl(&cmd.args, "--bisect", "--", NULL);
strbuf_read_file(&sb, git_path_bisect_names(), 0);
sq_dequote_to_strvec(sb.buf, &args);
sq_dequote_to_strvec(sb.buf, &cmd.args);
strbuf_release(&sb);
res = run_command_v_opt(args.v, flags);
strvec_clear(&args);
return res;
return run_command(&cmd);
}
static int get_first_good(const char *refname UNUSED,

33
builtin/clone.c
View File

@ -653,9 +653,9 @@ static void update_head(const struct ref *our, const struct ref *remote,
static int git_sparse_checkout_init(const char *repo)
{
struct strvec argv = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
int result = 0;
strvec_pushl(&argv, "-C", repo, "sparse-checkout", "set", NULL);
strvec_pushl(&cmd.args, "-C", repo, "sparse-checkout", "set", NULL);
/*
* We must apply the setting in the current process
@ -663,12 +663,12 @@ static int git_sparse_checkout_init(const char *repo)
*/
core_apply_sparse_checkout = 1;
if (run_command_v_opt(argv.v, RUN_GIT_CMD)) {
cmd.git_cmd = 1;
if (run_command(&cmd)) {
error(_("failed to initialize sparse-checkout"));
result = 1;
}
strvec_clear(&argv);
return result;
}
@ -733,37 +733,38 @@ static int checkout(int submodule_progress, int filter_submodules)
oid_to_hex(&oid), "1", NULL);
if (!err && (option_recurse_submodules.nr > 0)) {
struct strvec args = STRVEC_INIT;
strvec_pushl(&args, "submodule", "update", "--require-init", "--recursive", NULL);
struct child_process cmd = CHILD_PROCESS_INIT;
strvec_pushl(&cmd.args, "submodule", "update", "--require-init",
"--recursive", NULL);
if (option_shallow_submodules == 1)
strvec_push(&args, "--depth=1");
strvec_push(&cmd.args, "--depth=1");
if (max_jobs != -1)
strvec_pushf(&args, "--jobs=%d", max_jobs);
strvec_pushf(&cmd.args, "--jobs=%d", max_jobs);
if (submodule_progress)
strvec_push(&args, "--progress");
strvec_push(&cmd.args, "--progress");
if (option_verbosity < 0)
strvec_push(&args, "--quiet");
strvec_push(&cmd.args, "--quiet");
if (option_remote_submodules) {
strvec_push(&args, "--remote");
strvec_push(&args, "--no-fetch");
strvec_push(&cmd.args, "--remote");
strvec_push(&cmd.args, "--no-fetch");
}
if (filter_submodules && filter_options.choice)
strvec_pushf(&args, "--filter=%s",
strvec_pushf(&cmd.args, "--filter=%s",
expand_list_objects_filter_spec(&filter_options));
if (option_single_branch >= 0)
strvec_push(&args, option_single_branch ?
strvec_push(&cmd.args, option_single_branch ?
"--single-branch" :
"--no-single-branch");
err = run_command_v_opt(args.v, RUN_GIT_CMD);
strvec_clear(&args);
cmd.git_cmd = 1;
err = run_command(&cmd);
}
return err;

14
builtin/gc.c
View File

@ -1910,20 +1910,16 @@ static char *schtasks_task_name(const char *frequency)
static int schtasks_remove_task(enum schedule_priority schedule)
{
const char *cmd = "schtasks";
int result;
struct strvec args = STRVEC_INIT;
struct child_process child = CHILD_PROCESS_INIT;
const char *frequency = get_frequency(schedule);
char *name = schtasks_task_name(frequency);
get_schedule_cmd(&cmd, NULL);
strvec_split(&args, cmd);
strvec_pushl(&args, "/delete", "/tn", name, "/f", NULL);
result = run_command_v_opt(args.v, 0);
strvec_clear(&args);
strvec_split(&child.args, cmd);
strvec_pushl(&child.args, "/delete", "/tn", name, "/f", NULL);
free(name);
return result;
return run_command(&child);
}
static int schtasks_remove_tasks(void)

10
builtin/merge.c
View File

@ -372,22 +372,22 @@ static void reset_hard(const struct object_id *oid)
static void restore_state(const struct object_id *head,
const struct object_id *stash)
{
struct strvec args = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
reset_hard(head);
if (is_null_oid(stash))
goto refresh_cache;
strvec_pushl(&args, "stash", "apply", "--index", "--quiet", NULL);
strvec_push(&args, oid_to_hex(stash));
strvec_pushl(&cmd.args, "stash", "apply", "--index", "--quiet", NULL);
strvec_push(&cmd.args, oid_to_hex(stash));
/*
* It is OK to ignore error here, for example when there was
* nothing to restore.
*/
run_command_v_opt(args.v, RUN_GIT_CMD);
strvec_clear(&args);
cmd.git_cmd = 1;
run_command(&cmd);
refresh_cache:
if (discard_cache() < 0 || read_cache() < 0)

147
builtin/pull.c
View File

@ -515,76 +515,75 @@ static void parse_repo_refspecs(int argc, const char **argv, const char **repo,
*/
static int run_fetch(const char *repo, const char **refspecs)
{
struct strvec args = STRVEC_INIT;
int ret;
struct child_process cmd = CHILD_PROCESS_INIT;
strvec_pushl(&args, "fetch", "--update-head-ok", NULL);
strvec_pushl(&cmd.args, "fetch", "--update-head-ok", NULL);
/* Shared options */
argv_push_verbosity(&args);
argv_push_verbosity(&cmd.args);
if (opt_progress)
strvec_push(&args, opt_progress);
strvec_push(&cmd.args, opt_progress);
/* Options passed to git-fetch */
if (opt_all)
strvec_push(&args, opt_all);
strvec_push(&cmd.args, opt_all);
if (opt_append)
strvec_push(&args, opt_append);
strvec_push(&cmd.args, opt_append);
if (opt_upload_pack)
strvec_push(&args, opt_upload_pack);
argv_push_force(&args);
strvec_push(&cmd.args, opt_upload_pack);
argv_push_force(&cmd.args);
if (opt_tags)
strvec_push(&args, opt_tags);
strvec_push(&cmd.args, opt_tags);
if (opt_prune)
strvec_push(&args, opt_prune);
strvec_push(&cmd.args, opt_prune);
if (recurse_submodules_cli != RECURSE_SUBMODULES_DEFAULT)
switch (recurse_submodules_cli) {
case RECURSE_SUBMODULES_ON:
strvec_push(&args, "--recurse-submodules=on");
strvec_push(&cmd.args, "--recurse-submodules=on");
break;
case RECURSE_SUBMODULES_OFF:
strvec_push(&args, "--recurse-submodules=no");
strvec_push(&cmd.args, "--recurse-submodules=no");
break;
case RECURSE_SUBMODULES_ON_DEMAND:
strvec_push(&args, "--recurse-submodules=on-demand");
strvec_push(&cmd.args, "--recurse-submodules=on-demand");
break;
default:
BUG("submodule recursion option not understood");
}
if (max_children)
strvec_push(&args, max_children);
strvec_push(&cmd.args, max_children);
if (opt_dry_run)
strvec_push(&args, "--dry-run");
strvec_push(&cmd.args, "--dry-run");
if (opt_keep)
strvec_push(&args, opt_keep);
strvec_push(&cmd.args, opt_keep);
if (opt_depth)
strvec_push(&args, opt_depth);
strvec_push(&cmd.args, opt_depth);
if (opt_unshallow)
strvec_push(&args, opt_unshallow);
strvec_push(&cmd.args, opt_unshallow);
if (opt_update_shallow)
strvec_push(&args, opt_update_shallow);
strvec_push(&cmd.args, opt_update_shallow);
if (opt_refmap)
strvec_push(&args, opt_refmap);
strvec_push(&cmd.args, opt_refmap);
if (opt_ipv4)
strvec_push(&args, opt_ipv4);
strvec_push(&cmd.args, opt_ipv4);
if (opt_ipv6)
strvec_push(&args, opt_ipv6);
strvec_push(&cmd.args, opt_ipv6);
if (opt_show_forced_updates > 0)
strvec_push(&args, "--show-forced-updates");
strvec_push(&cmd.args, "--show-forced-updates");
else if (opt_show_forced_updates == 0)
strvec_push(&args, "--no-show-forced-updates");
strvec_push(&cmd.args, "--no-show-forced-updates");
if (set_upstream)
strvec_push(&args, set_upstream);
strvec_pushv(&args, opt_fetch.v);
strvec_push(&cmd.args, set_upstream);
strvec_pushv(&cmd.args, opt_fetch.v);
if (repo) {
strvec_push(&args, repo);
strvec_pushv(&args, refspecs);
strvec_push(&cmd.args, repo);
strvec_pushv(&cmd.args, refspecs);
} else if (*refspecs)
BUG("refspecs without repo?");
ret = run_command_v_opt(args.v, RUN_GIT_CMD | RUN_CLOSE_OBJECT_STORE);
strvec_clear(&args);
return ret;
cmd.git_cmd = 1;
cmd.close_object_store = 1;
return run_command(&cmd);
}
/**
@ -653,52 +652,50 @@ static int update_submodules(void)
*/
static int run_merge(void)
{
int ret;
struct strvec args = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
strvec_pushl(&args, "merge", NULL);
strvec_pushl(&cmd.args, "merge", NULL);
/* Shared options */
argv_push_verbosity(&args);
argv_push_verbosity(&cmd.args);
if (opt_progress)
strvec_push(&args, opt_progress);
strvec_push(&cmd.args, opt_progress);
/* Options passed to git-merge */
if (opt_diffstat)
strvec_push(&args, opt_diffstat);
strvec_push(&cmd.args, opt_diffstat);
if (opt_log)
strvec_push(&args, opt_log);
strvec_push(&cmd.args, opt_log);
if (opt_signoff)
strvec_push(&args, opt_signoff);
strvec_push(&cmd.args, opt_signoff);
if (opt_squash)
strvec_push(&args, opt_squash);
strvec_push(&cmd.args, opt_squash);
if (opt_commit)
strvec_push(&args, opt_commit);
strvec_push(&cmd.args, opt_commit);
if (opt_edit)
strvec_push(&args, opt_edit);
strvec_push(&cmd.args, opt_edit);
if (cleanup_arg)
strvec_pushf(&args, "--cleanup=%s", cleanup_arg);
strvec_pushf(&cmd.args, "--cleanup=%s", cleanup_arg);
if (opt_ff)
strvec_push(&args, opt_ff);
strvec_push(&cmd.args, opt_ff);
if (opt_verify)
strvec_push(&args, opt_verify);
strvec_push(&cmd.args, opt_verify);
if (opt_verify_signatures)
strvec_push(&args, opt_verify_signatures);
strvec_pushv(&args, opt_strategies.v);
strvec_pushv(&args, opt_strategy_opts.v);
strvec_push(&cmd.args, opt_verify_signatures);
strvec_pushv(&cmd.args, opt_strategies.v);
strvec_pushv(&cmd.args, opt_strategy_opts.v);
if (opt_gpg_sign)
strvec_push(&args, opt_gpg_sign);
strvec_push(&cmd.args, opt_gpg_sign);
if (opt_autostash == 0)
strvec_push(&args, "--no-autostash");
strvec_push(&cmd.args, "--no-autostash");
else if (opt_autostash == 1)
strvec_push(&args, "--autostash");
strvec_push(&cmd.args, "--autostash");
if (opt_allow_unrelated_histories > 0)
strvec_push(&args, "--allow-unrelated-histories");
strvec_push(&cmd.args, "--allow-unrelated-histories");
strvec_push(&args, "FETCH_HEAD");
ret = run_command_v_opt(args.v, RUN_GIT_CMD);
strvec_clear(&args);
return ret;
strvec_push(&cmd.args, "FETCH_HEAD");
cmd.git_cmd = 1;
return run_command(&cmd);
}
/**
@ -879,43 +876,41 @@ static int get_rebase_newbase_and_upstream(struct object_id *newbase,
static int run_rebase(const struct object_id *newbase,
const struct object_id *upstream)
{
int ret;
struct strvec args = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
strvec_push(&args, "rebase");
strvec_push(&cmd.args, "rebase");
/* Shared options */
argv_push_verbosity(&args);
argv_push_verbosity(&cmd.args);
/* Options passed to git-rebase */
if (opt_rebase == REBASE_MERGES)
strvec_push(&args, "--rebase-merges");
strvec_push(&cmd.args, "--rebase-merges");
else if (opt_rebase == REBASE_INTERACTIVE)
strvec_push(&args, "--interactive");
strvec_push(&cmd.args, "--interactive");
if (opt_diffstat)
strvec_push(&args, opt_diffstat);
strvec_pushv(&args, opt_strategies.v);
strvec_pushv(&args, opt_strategy_opts.v);
strvec_push(&cmd.args, opt_diffstat);
strvec_pushv(&cmd.args, opt_strategies.v);
strvec_pushv(&cmd.args, opt_strategy_opts.v);
if (opt_gpg_sign)
strvec_push(&args, opt_gpg_sign);
strvec_push(&cmd.args, opt_gpg_sign);
if (opt_signoff)
strvec_push(&args, opt_signoff);
strvec_push(&cmd.args, opt_signoff);
if (opt_autostash == 0)
strvec_push(&args, "--no-autostash");
strvec_push(&cmd.args, "--no-autostash");
else if (opt_autostash == 1)
strvec_push(&args, "--autostash");
strvec_push(&cmd.args, "--autostash");
if (opt_verify_signatures &&
!strcmp(opt_verify_signatures, "--verify-signatures"))
warning(_("ignoring --verify-signatures for rebase"));
strvec_push(&args, "--onto");
strvec_push(&args, oid_to_hex(newbase));
strvec_push(&cmd.args, "--onto");
strvec_push(&cmd.args, oid_to_hex(newbase));
strvec_push(&args, oid_to_hex(upstream));
strvec_push(&cmd.args, oid_to_hex(upstream));
ret = run_command_v_opt(args.v, RUN_GIT_CMD);
strvec_clear(&args);
return ret;
cmd.git_cmd = 1;
return run_command(&cmd);
}
static int get_can_ff(struct object_id *orig_head,

26
builtin/remote.c
View File

@ -1510,37 +1510,35 @@ static int update(int argc, const char **argv, const char *prefix)
N_("prune remotes after fetching")),
OPT_END()
};
struct strvec fetch_argv = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
int default_defined = 0;
int retval;
argc = parse_options(argc, argv, prefix, options,
builtin_remote_update_usage,
PARSE_OPT_KEEP_ARGV0);
strvec_push(&fetch_argv, "fetch");
strvec_push(&cmd.args, "fetch");
if (prune != -1)
strvec_push(&fetch_argv, prune ? "--prune" : "--no-prune");
strvec_push(&cmd.args, prune ? "--prune" : "--no-prune");
if (verbose)
strvec_push(&fetch_argv, "-v");
strvec_push(&fetch_argv, "--multiple");
strvec_push(&cmd.args, "-v");
strvec_push(&cmd.args, "--multiple");
if (argc < 2)
strvec_push(&fetch_argv, "default");
strvec_push(&cmd.args, "default");
for (i = 1; i < argc; i++)
strvec_push(&fetch_argv, argv[i]);
strvec_push(&cmd.args, argv[i]);
if (strcmp(fetch_argv.v[fetch_argv.nr-1], "default") == 0) {
if (strcmp(cmd.args.v[cmd.args.nr-1], "default") == 0) {
git_config(get_remote_default, &default_defined);
if (!default_defined) {
strvec_pop(&fetch_argv);
strvec_push(&fetch_argv, "--all");
strvec_pop(&cmd.args);
strvec_push(&cmd.args, "--all");
}
}
retval = run_command_v_opt(fetch_argv.v, RUN_GIT_CMD);
strvec_clear(&fetch_argv);
return retval;
cmd.git_cmd = 1;
return run_command(&cmd);
}
static int remove_all_fetch_refspecs(const char *key)

27
diff.c
View File

@ -4278,35 +4278,34 @@ static void run_external_diff(const char *pgm,
const char *xfrm_msg,
struct diff_options *o)
{
struct strvec argv = STRVEC_INIT;
struct strvec env = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
struct diff_queue_struct *q = &diff_queued_diff;
strvec_push(&argv, pgm);
strvec_push(&argv, name);
strvec_push(&cmd.args, pgm);
strvec_push(&cmd.args, name);
if (one && two) {
add_external_diff_name(o->repo, &argv, name, one);
add_external_diff_name(o->repo, &cmd.args, name, one);
if (!other)
add_external_diff_name(o->repo, &argv, name, two);
add_external_diff_name(o->repo, &cmd.args, name, two);
else {
add_external_diff_name(o->repo, &argv, other, two);
strvec_push(&argv, other);
strvec_push(&argv, xfrm_msg);
add_external_diff_name(o->repo, &cmd.args, other, two);
strvec_push(&cmd.args, other);
strvec_push(&cmd.args, xfrm_msg);
}
}
strvec_pushf(&env, "GIT_DIFF_PATH_COUNTER=%d", ++o->diff_path_counter);
strvec_pushf(&env, "GIT_DIFF_PATH_TOTAL=%d", q->nr);
strvec_pushf(&cmd.env, "GIT_DIFF_PATH_COUNTER=%d",
++o->diff_path_counter);
strvec_pushf(&cmd.env, "GIT_DIFF_PATH_TOTAL=%d", q->nr);
diff_free_filespec_data(one);
diff_free_filespec_data(two);
if (run_command_v_opt_cd_env(argv.v, RUN_USING_SHELL, NULL, env.v))
cmd.use_shell = 1;
if (run_command(&cmd))
die(_("external diff died, stopping at %s"), name);
remove_tempfile();
strvec_clear(&argv);
strvec_clear(&env);
}
static int similarity_index(struct diff_filepair *p)

15
git.c
View File

@ -787,7 +787,7 @@ static int run_argv(int *argcp, const char ***argv)
if (!done_alias)
handle_builtin(*argcp, *argv);
else if (get_builtin(**argv)) {
struct strvec args = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
int i;
/*
@ -804,18 +804,21 @@ static int run_argv(int *argcp, const char ***argv)
commit_pager_choice();
strvec_push(&args, "git");
strvec_push(&cmd.args, "git");
for (i = 0; i < *argcp; i++)
strvec_push(&args, (*argv)[i]);
strvec_push(&cmd.args, (*argv)[i]);
trace_argv_printf(args.v, "trace: exec:");
trace_argv_printf(cmd.args.v, "trace: exec:");
/*
* if we fail because the command is not found, it is
* OK to return. Otherwise, we just pass along the status code.
*/
i = run_command_v_opt_tr2(args.v, RUN_SILENT_EXEC_FAILURE |
RUN_CLEAN_ON_EXIT | RUN_WAIT_AFTER_CLEAN, "git_alias");
cmd.silent_exec_failure = 1;
cmd.clean_on_exit = 1;
cmd.wait_after_clean = 1;
cmd.trace2_child_class = "git_alias";
i = run_command(&cmd);
if (i >= 0 || errno != ENOENT)
exit(i);
die("could not execute builtin %s", **argv);

18
merge.c
View File

@ -19,22 +19,22 @@ int try_merge_command(struct repository *r,
const char **xopts, struct commit_list *common,
const char *head_arg, struct commit_list *remotes)
{
struct strvec args = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
int i, ret;
struct commit_list *j;
strvec_pushf(&args, "merge-%s", strategy);
strvec_pushf(&cmd.args, "merge-%s", strategy);
for (i = 0; i < xopts_nr; i++)
strvec_pushf(&args, "--%s", xopts[i]);
strvec_pushf(&cmd.args, "--%s", xopts[i]);
for (j = common; j; j = j->next)
strvec_push(&args, merge_argument(j->item));
strvec_push(&args, "--");
strvec_push(&args, head_arg);
strvec_push(&cmd.args, merge_argument(j->item));
strvec_push(&cmd.args, "--");
strvec_push(&cmd.args, head_arg);
for (j = remotes; j; j = j->next)
strvec_push(&args, merge_argument(j->item));
strvec_push(&cmd.args, merge_argument(j->item));
ret = run_command_v_opt(args.v, RUN_GIT_CMD);
strvec_clear(&args);
cmd.git_cmd = 1;
ret = run_command(&cmd);
discard_index(r->index);
if (repo_read_index(r) < 0)

13
scalar.c
View File

@ -69,21 +69,18 @@ static void setup_enlistment_directory(int argc, const char **argv,
static int run_git(const char *arg, ...)
{
struct strvec argv = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
va_list args;
const char *p;
int res;
va_start(args, arg);
strvec_push(&argv, arg);
strvec_push(&cmd.args, arg);
while ((p = va_arg(args, const char *)))
strvec_push(&argv, p);
strvec_push(&cmd.args, p);
va_end(args);
res = run_command_v_opt(argv.v, RUN_GIT_CMD);
strvec_clear(&argv);
return res;
cmd.git_cmd = 1;
return run_command(&cmd);
}
struct scalar_config {

25
sequencer.c
View File

@ -3183,18 +3183,15 @@ static int rollback_is_safe(void)
static int reset_merge(const struct object_id *oid)
{
int ret;
struct strvec argv = STRVEC_INIT;
struct child_process cmd = CHILD_PROCESS_INIT;
strvec_pushl(&argv, "reset", "--merge", NULL);
cmd.git_cmd = 1;
strvec_pushl(&cmd.args, "reset", "--merge", NULL);
if (!is_null_oid(oid))
strvec_push(&argv, oid_to_hex(oid));
strvec_push(&cmd.args, oid_to_hex(oid));
ret = run_command_v_opt(argv.v, RUN_GIT_CMD);
strvec_clear(&argv);
return ret;
return run_command(&cmd);
}
static int rollback_single_pick(struct repository *r)
@ -4866,14 +4863,14 @@ cleanup_head_ref:
static int continue_single_pick(struct repository *r, struct replay_opts *opts)
{
struct strvec argv = STRVEC_INIT;
int ret;
struct child_process cmd = CHILD_PROCESS_INIT;
if (!refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
!refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
return error(_("no cherry-pick or revert in progress"));
strvec_push(&argv, "commit");
cmd.git_cmd = 1;
strvec_push(&cmd.args, "commit");
/*
* continue_single_pick() handles the case of recovering from a
@ -4886,11 +4883,9 @@ static int continue_single_pick(struct repository *r, struct replay_opts *opts)
* Include --cleanup=strip as well because we don't want the
* "# Conflicts:" messages.
*/
strvec_pushl(&argv, "--no-edit", "--cleanup=strip", NULL);
strvec_pushl(&cmd.args, "--no-edit", "--cleanup=strip", NULL);
ret = run_command_v_opt(argv.v, RUN_GIT_CMD);
strvec_clear(&argv);
return ret;
return run_command(&cmd);
}
static int commit_staged_changes(struct repository *r,