worktree: introduce "add" command

diff --git a/run-command.c b/run-command.c
index 35a3ebf07b1792ac7b0ecef30781223591413093..c4a62aa0e8fb8eba8d6972461eed07097a52a976 100644 (file)
--- a/run-command.c
+++ b/run-command.c
@@ -8,6 +8,13 @@
 # define SHELL_PATH "/bin/sh"
 #endif
 
+void child_process_init(struct child_process *child)
+{
+       memset(child, 0, sizeof(*child));
+       argv_array_init(&child->args);
+       argv_array_init(&child->env_array);
+}
+
 struct child_to_clean {
        pid_t pid;
        struct child_to_clean *next;
@@ -281,6 +288,8 @@ int start_command(struct child_process *cmd)
 
        if (!cmd->argv)
                cmd->argv = cmd->args.argv;
+       if (!cmd->env)
+               cmd->env = cmd->env_array.argv;
 
        /*
         * In case of errors we must keep the promise to close FDs
@@ -332,6 +341,7 @@ int start_command(struct child_process *cmd)
                        error("cannot create %s pipe for %s: %s",
                                str, cmd->argv[0], strerror(failed_errno));
                        argv_array_clear(&cmd->args);
+                       argv_array_clear(&cmd->env_array);
                        errno = failed_errno;
                        return -1;
                }
@@ -518,6 +528,7 @@ int start_command(struct child_process *cmd)
                else if (cmd->err)
                        close(cmd->err);
                argv_array_clear(&cmd->args);
+               argv_array_clear(&cmd->env_array);
                errno = failed_errno;
                return -1;
        }
@@ -544,6 +555,7 @@ int finish_command(struct child_process *cmd)
 {
        int ret = wait_or_whine(cmd->pid, cmd->argv[0]);
        argv_array_clear(&cmd->args);
+       argv_array_clear(&cmd->env_array);
        return ret;
 }
 
@@ -555,31 +567,21 @@ int run_command(struct child_process *cmd)
        return finish_command(cmd);
 }
 
-static void prepare_run_command_v_opt(struct child_process *cmd,
-                                     const char **argv,
-                                     int opt)
-{
-       memset(cmd, 0, sizeof(*cmd));
-       cmd->argv = argv;
-       cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
-       cmd->git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
-       cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
-       cmd->silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
-       cmd->use_shell = opt & RUN_USING_SHELL ? 1 : 0;
-       cmd->clean_on_exit = opt & RUN_CLEAN_ON_EXIT ? 1 : 0;
-}
-
 int run_command_v_opt(const char **argv, int opt)
 {
-       struct child_process cmd;
-       prepare_run_command_v_opt(&cmd, argv, opt);
-       return run_command(&cmd);
+       return run_command_v_opt_cd_env(argv, opt, NULL, NULL);
 }
 
 int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
 {
-       struct child_process cmd;
-       prepare_run_command_v_opt(&cmd, argv, opt);
+       struct child_process cmd = CHILD_PROCESS_INIT;
+       cmd.argv = argv;
+       cmd.no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
+       cmd.git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
+       cmd.stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
+       cmd.silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
+       cmd.use_shell = opt & RUN_USING_SHELL ? 1 : 0;
+       cmd.clean_on_exit = opt & RUN_CLEAN_ON_EXIT ? 1 : 0;
        cmd.dir = dir;
        cmd.env = env;
        return run_command(&cmd);
@@ -624,6 +626,45 @@ static int async_die_is_recursing(void)
        return ret != NULL;
 }
 
+#else
+
+static struct {
+       void (**handlers)(void);
+       size_t nr;
+       size_t alloc;
+} git_atexit_hdlrs;
+
+static int git_atexit_installed;
+
+static void git_atexit_dispatch(void)
+{
+       size_t i;
+
+       for (i=git_atexit_hdlrs.nr ; i ; i--)
+               git_atexit_hdlrs.handlers[i-1]();
+}
+
+static void git_atexit_clear(void)
+{
+       free(git_atexit_hdlrs.handlers);
+       memset(&git_atexit_hdlrs, 0, sizeof(git_atexit_hdlrs));
+       git_atexit_installed = 0;
+}
+
+#undef atexit
+int git_atexit(void (*handler)(void))
+{
+       ALLOC_GROW(git_atexit_hdlrs.handlers, git_atexit_hdlrs.nr + 1, git_atexit_hdlrs.alloc);
+       git_atexit_hdlrs.handlers[git_atexit_hdlrs.nr++] = handler;
+       if (!git_atexit_installed) {
+               if (atexit(&git_atexit_dispatch))
+                       return -1;
+               git_atexit_installed = 1;
+       }
+       return 0;
+}
+#define atexit git_atexit
+
 #endif
 
 int start_async(struct async *async)
@@ -682,6 +723,7 @@ int start_async(struct async *async)
                        close(fdin[1]);
                if (need_out)
                        close(fdout[0]);
+               git_atexit_clear();
                exit(!!async->proc(proc_in, proc_out, async->data));
        }
 
@@ -752,9 +794,9 @@ int finish_async(struct async *async)
 #endif
 }
 
-char *find_hook(const char *name)
+const char *find_hook(const char *name)
 {
-       char *path = git_path("hooks/%s", name);
+       const char *path = git_path("hooks/%s", name);
        if (access(path, X_OK) < 0)
                path = NULL;
 
@@ -763,14 +805,13 @@ char *find_hook(const char *name)
 
 int run_hook_ve(const char *const *env, const char *name, va_list args)
 {
-       struct child_process hook;
+       struct child_process hook = CHILD_PROCESS_INIT;
        const char *p;
 
        p = find_hook(name);
        if (!p)
                return 0;
 
-       memset(&hook, 0, sizeof(hook));
        argv_array_push(&hook.args, p);
        while ((p = va_arg(args, const char *)))
                argv_array_push(&hook.args, p);