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>

diff --git a/add-interactive.c b/add-interactive.c
index f071b2a1b4f2ee8bf1959706d1778c3697d81ba7..ecc5ae1b2499c56beae72ec4756011b4b8296134 100644 (file)
--- a/add-interactive.c
+++ b/add-interactive.c
@@ -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');

diff --git a/builtin/add.c b/builtin/add.c
index f84372964c8c486601941c927d6e39bb8da42084..626c71ec6aac6ff92ca2cb168ad6e4b6846cebd3 100644 (file)
--- a/builtin/add.c
+++ b/builtin/add.c
@@ -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)

diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 70d1e9d1adc653694ff0a063542e2373b1c42a8c..5c63ba6994f70b4a1b65cb1529583448e1d36a2c 100644 (file)
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -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,

diff --git a/builtin/clone.c b/builtin/clone.c
index 547d6464b3c04b83cb1376d325eeefb79aca079c..56e7775daefe7f6ae26138c1fbf1cb132c15c9f9 100644 (file)
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -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;

diff --git a/builtin/gc.c b/builtin/gc.c
index 243ee85d283297a7e08b81c24155a8a58abebf17..87ad0077d8cc81b9d308d500f282947cf034b1ce 100644 (file)
--- a/builtin/gc.c
+++ b/builtin/gc.c
@@ -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)

diff --git a/builtin/merge.c b/builtin/merge.c
index 34815771454d15338e7c88af625c8c8f769d521c..b3f75f55c8a82db92f31b7f32a503eb70357e9c8 100644 (file)
--- a/builtin/merge.c
+++ b/builtin/merge.c
@@ -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)

diff --git a/builtin/pull.c b/builtin/pull.c
index 403a24d7ca670f9a5c56ebfb6d8429b5e5817b54..b21edd767aaf31d36cf938451812e1dd45584985 100644 (file)
--- a/builtin/pull.c
+++ b/builtin/pull.c
@@ -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,

diff --git a/builtin/remote.c b/builtin/remote.c
index 7cccd9fae2770423e16f0f622ea482855cf3cb68..12632676cd0537f58da323c6752279b8fe15ecb5 100644 (file)
--- a/builtin/remote.c
+++ b/builtin/remote.c
@@ -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)

diff --git a/diff.c b/diff.c
index 648f6717a5597c30c423256a25e0fece08cd30de..8451c230d9e7eac820a886d9b50a22c4e8e131bb 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -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)

diff --git a/git.c b/git.c
index ee7758dcb0e40e660c41001cd3c05f64ffcfb54c..6662548986f7b95422fa7858430b06dbb04c6f2b 100644 (file)
--- a/git.c
+++ b/git.c
@@ -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);

diff --git a/merge.c b/merge.c
index 2382ff66d351cce20848b6f2ff056258adb2d4d7..445b4f19aa8618b5641f3f007e8cb42d9d39b57c 100644 (file)
--- a/merge.c
+++ b/merge.c
@@ -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)

diff --git a/scalar.c b/scalar.c
index 6de9c0ee523abe56881d9d0158b8ff6a7e07c866..03f9e480dd6a4a6bdafb57d6da48be74e6ba3bf6 100644 (file)
--- a/scalar.c
+++ b/scalar.c
@@ -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 {

diff --git a/sequencer.c b/sequencer.c
index 66eedd2c76434b8579ec3bc02d8e641df5f46f23..31e24f38f8f2221dcd2942add9ed59512bb26487 100644 (file)
--- a/sequencer.c
+++ b/sequencer.c
@@ -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,