revert: Introduce struct to keep command-line options

The current code uses a set of file-scope static variables to tell the
cherry-pick/ revert machinery how to replay the changes, and
initializes them by parsing the command-line arguments.  In later
steps in this series, we would like to introduce an API function that
calls into this machinery directly and have a way to tell it what to
do.  Hence, introduce a structure to group these variables, so that
the API can take them as a single replay_options parameter.  The only
exception is the variable "me" -- remove it since it not an
independent option, and can be inferred from the action.

Unfortunately, this patch introduces a minor regression.  Parsing
strategy-option violates a C89 rule: Initializers cannot refer to
variables whose address is not known at compile time.  Currently, this
rule is violated by some other parts of Git as well, and it is
possible to get GCC to report these instances using the "-std=c89
-pedantic" option.

Inspired-by: Christian Couder <chriscool@tuxfamily.org>
Mentored-by: Jonathan Nieder <jrnieder@gmail.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Ramkumar Ramachandra <artagnon@gmail.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/revert.c b/builtin/revert.c
index d6c9f1dadb8f002d0c859ce6698a6fba8874904a..50f72debe03b75c9d73617f18f146a1d9c374ebd 100644 (file)
--- a/builtin/revert.c
+++ b/builtin/revert.c
@@ -35,76 +35,94 @@ static const char * const cherry_pick_usage[] = {
        NULL
 };
 
        NULL
 };
 

-static int edit, record_origin, no_commit, mainline, signoff, allow_ff;
-static enum { REVERT, CHERRY_PICK } action;
-static int commit_argc;
-static const char **commit_argv;
-static int allow_rerere_auto;
-
-static const char *me;
-
-/* Merge strategy. */
-static const char *strategy;
-static const char **xopts;
-static size_t xopts_nr, xopts_alloc;
+enum replay_action { REVERT, CHERRY_PICK };
+
+struct replay_opts {
+       enum replay_action action;
+
+       /* Boolean options */
+       int edit;
+       int record_origin;
+       int no_commit;
+       int signoff;
+       int allow_ff;
+       int allow_rerere_auto;
+
+       int mainline;
+       int commit_argc;
+       const char **commit_argv;
+
+       /* Merge strategy */
+       const char *strategy;
+       const char **xopts;
+       size_t xopts_nr, xopts_alloc;
+};

 
 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
 
 
 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
 

+static const char *action_name(const struct replay_opts *opts)
+{
+       return opts->action == REVERT ? "revert" : "cherry-pick";
+}
+

 static char *get_encoding(const char *message);
 
 static char *get_encoding(const char *message);
 

-static const char * const *revert_or_cherry_pick_usage(void)
+static const char * const *revert_or_cherry_pick_usage(struct replay_opts *opts)

 {
 {

-       return action == REVERT ? revert_usage : cherry_pick_usage;
+       return opts->action == REVERT ? revert_usage : cherry_pick_usage;

 }
 
 static int option_parse_x(const struct option *opt,
                          const char *arg, int unset)
 {
 }
 
 static int option_parse_x(const struct option *opt,
                          const char *arg, int unset)
 {

+       struct replay_opts **opts_ptr = opt->value;
+       struct replay_opts *opts = *opts_ptr;
+

        if (unset)
                return 0;
 
        if (unset)
                return 0;
 

-       ALLOC_GROW(xopts, xopts_nr + 1, xopts_alloc);
-       xopts[xopts_nr++] = xstrdup(arg);
+       ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
+       opts->xopts[opts->xopts_nr++] = xstrdup(arg);

        return 0;
 }
 
        return 0;
 }
 

-static void parse_args(int argc, const char **argv)
+static void parse_args(int argc, const char **argv, struct replay_opts *opts)

 {
 {

-       const char * const * usage_str = revert_or_cherry_pick_usage();
+       const char * const * usage_str = revert_or_cherry_pick_usage(opts);

        int noop;
        struct option options[] = {
        int noop;
        struct option options[] = {

-               OPT_BOOLEAN('n', "no-commit", &no_commit, "don't automatically commit"),
-               OPT_BOOLEAN('e', "edit", &edit, "edit the commit message"),
+               OPT_BOOLEAN('n', "no-commit", &opts->no_commit, "don't automatically commit"),
+               OPT_BOOLEAN('e', "edit", &opts->edit, "edit the commit message"),

                { OPTION_BOOLEAN, 'r', NULL, &noop, NULL, "no-op (backward compatibility)",
                  PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, NULL, 0 },
                { OPTION_BOOLEAN, 'r', NULL, &noop, NULL, "no-op (backward compatibility)",
                  PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, NULL, 0 },

-               OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
-               OPT_INTEGER('m', "mainline", &mainline, "parent number"),
-               OPT_RERERE_AUTOUPDATE(&allow_rerere_auto),
-               OPT_STRING(0, "strategy", &strategy, "strategy", "merge strategy"),
-               OPT_CALLBACK('X', "strategy-option", &xopts, "option",
+               OPT_BOOLEAN('s', "signoff", &opts->signoff, "add Signed-off-by:"),
+               OPT_INTEGER('m', "mainline", &opts->mainline, "parent number"),
+               OPT_RERERE_AUTOUPDATE(&opts->allow_rerere_auto),
+               OPT_STRING(0, "strategy", &opts->strategy, "strategy", "merge strategy"),
+               OPT_CALLBACK('X', "strategy-option", &opts, "option",

                        "option for merge strategy", option_parse_x),
                OPT_END(),
                OPT_END(),
                OPT_END(),
        };
 
                        "option for merge strategy", option_parse_x),
                OPT_END(),
                OPT_END(),
                OPT_END(),
        };
 

-       if (action == CHERRY_PICK) {
+       if (opts->action == CHERRY_PICK) {

                struct option cp_extra[] = {
                struct option cp_extra[] = {

-                       OPT_BOOLEAN('x', NULL, &record_origin, "append commit name"),
-                       OPT_BOOLEAN(0, "ff", &allow_ff, "allow fast-forward"),
+                       OPT_BOOLEAN('x', NULL, &opts->record_origin, "append commit name"),
+                       OPT_BOOLEAN(0, "ff", &opts->allow_ff, "allow fast-forward"),

                        OPT_END(),
                };
                if (parse_options_concat(options, ARRAY_SIZE(options), cp_extra))
                        die(_("program error"));
        }
 
                        OPT_END(),
                };
                if (parse_options_concat(options, ARRAY_SIZE(options), cp_extra))
                        die(_("program error"));
        }
 

-       commit_argc = parse_options(argc, argv, NULL, options, usage_str,
-                                   PARSE_OPT_KEEP_ARGV0 |
-                                   PARSE_OPT_KEEP_UNKNOWN);
-       if (commit_argc < 2)
+       opts->commit_argc = parse_options(argc, argv, NULL, options, usage_str,
+                                       PARSE_OPT_KEEP_ARGV0 |
+                                       PARSE_OPT_KEEP_UNKNOWN);
+       if (opts->commit_argc < 2)

                usage_with_options(usage_str, options);
 
                usage_with_options(usage_str, options);
 

-       commit_argv = argv;
+       opts->commit_argv = argv;

 }
 
 struct commit_message {
 }
 
 struct commit_message {


@@ -240,20 +258,20 @@ static struct tree *empty_tree(void)
        return tree;
 }
 
        return tree;
 }
 

-static NORETURN void die_dirty_index(const char *me)
+static NORETURN void die_dirty_index(struct replay_opts *opts)

 {
        if (read_cache_unmerged()) {
 {
        if (read_cache_unmerged()) {

-               die_resolve_conflict(me);
+               die_resolve_conflict(action_name(opts));

        } else {
                if (advice_commit_before_merge) {
        } else {
                if (advice_commit_before_merge) {

-                       if (action == REVERT)
+                       if (opts->action == REVERT)

                                die(_("Your local changes would be overwritten by revert.\n"
                                          "Please, commit your changes or stash them to proceed."));
                        else
                                die(_("Your local changes would be overwritten by cherry-pick.\n"
                                          "Please, commit your changes or stash them to proceed."));
                } else {
                                die(_("Your local changes would be overwritten by revert.\n"
                                          "Please, commit your changes or stash them to proceed."));
                        else
                                die(_("Your local changes would be overwritten by cherry-pick.\n"
                                          "Please, commit your changes or stash them to proceed."));
                } else {

-                       if (action == REVERT)
+                       if (opts->action == REVERT)

                                die(_("Your local changes would be overwritten by revert.\n"));
                        else
                                die(_("Your local changes would be overwritten by cherry-pick.\n"));
                                die(_("Your local changes would be overwritten by revert.\n"));
                        else
                                die(_("Your local changes would be overwritten by cherry-pick.\n"));


@@ -274,7 +292,8 @@ static int fast_forward_to(const unsigned char *to, const unsigned char *from)
 
 static int do_recursive_merge(struct commit *base, struct commit *next,
                              const char *base_label, const char *next_label,
 
 static int do_recursive_merge(struct commit *base, struct commit *next,
                              const char *base_label, const char *next_label,

-                             unsigned char *head, struct strbuf *msgbuf)
+                             unsigned char *head, struct strbuf *msgbuf,
+                             struct replay_opts *opts)

 {
        struct merge_options o;
        struct tree *result, *next_tree, *base_tree, *head_tree;
 {
        struct merge_options o;
        struct tree *result, *next_tree, *base_tree, *head_tree;


@@ -295,7 +314,7 @@ static int do_recursive_merge(struct commit *base, struct commit *next,
        next_tree = next ? next->tree : empty_tree();
        base_tree = base ? base->tree : empty_tree();
 
        next_tree = next ? next->tree : empty_tree();
        base_tree = base ? base->tree : empty_tree();
 

-       for (xopt = xopts; xopt != xopts + xopts_nr; xopt++)
+       for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)

                parse_merge_opt(&o, *xopt);
 
        clean = merge_trees(&o,
                parse_merge_opt(&o, *xopt);
 
        clean = merge_trees(&o,


@@ -306,7 +325,7 @@ static int do_recursive_merge(struct commit *base, struct commit *next,
            (write_cache(index_fd, active_cache, active_nr) ||
             commit_locked_index(&index_lock)))
                /* TRANSLATORS: %s will be "revert" or "cherry-pick" */
            (write_cache(index_fd, active_cache, active_nr) ||
             commit_locked_index(&index_lock)))
                /* TRANSLATORS: %s will be "revert" or "cherry-pick" */

-               die(_("%s: Unable to write new index file"), me);
+               die(_("%s: Unable to write new index file"), action_name(opts));

        rollback_lock_file(&index_lock);
 
        if (!clean) {
        rollback_lock_file(&index_lock);
 
        if (!clean) {


@@ -335,7 +354,7 @@ static int do_recursive_merge(struct commit *base, struct commit *next,
  * If we are revert, or if our cherry-pick results in a hand merge,
  * we had better say that the current user is responsible for that.
  */
  * If we are revert, or if our cherry-pick results in a hand merge,
  * we had better say that the current user is responsible for that.
  */

-static int run_git_commit(const char *defmsg)
+static int run_git_commit(const char *defmsg, struct replay_opts *opts)

 {
        /* 6 is max possible length of our args array including NULL */
        const char *args[6];
 {
        /* 6 is max possible length of our args array including NULL */
        const char *args[6];


@@ -343,9 +362,9 @@ static int run_git_commit(const char *defmsg)
 
        args[i++] = "commit";
        args[i++] = "-n";
 
        args[i++] = "commit";
        args[i++] = "-n";

-       if (signoff)
+       if (opts->signoff)

                args[i++] = "-s";
                args[i++] = "-s";

-       if (!edit) {
+       if (!opts->edit) {

                args[i++] = "-F";
                args[i++] = defmsg;
        }
                args[i++] = "-F";
                args[i++] = defmsg;
        }


@@ -354,7 +373,7 @@ static int run_git_commit(const char *defmsg)
        return run_command_v_opt(args, RUN_GIT_CMD);
 }
 
        return run_command_v_opt(args, RUN_GIT_CMD);
 }
 

-static int do_pick_commit(struct commit *commit)
+static int do_pick_commit(struct commit *commit, struct replay_opts *opts)

 {
        unsigned char head[20];
        struct commit *base, *next, *parent;
 {
        unsigned char head[20];
        struct commit *base, *next, *parent;


@@ -364,7 +383,7 @@ static int do_pick_commit(struct commit *commit)
        struct strbuf msgbuf = STRBUF_INIT;
        int res;
 
        struct strbuf msgbuf = STRBUF_INIT;
        int res;
 

-       if (no_commit) {
+       if (opts->no_commit) {

                /*
                 * We do not intend to commit immediately.  We just want to
                 * merge the differences in, so let's compute the tree
                /*
                 * We do not intend to commit immediately.  We just want to
                 * merge the differences in, so let's compute the tree


@@ -377,7 +396,7 @@ static int do_pick_commit(struct commit *commit)
                if (get_sha1("HEAD", head))
                        die (_("You do not have a valid HEAD"));
                if (index_differs_from("HEAD", 0))
                if (get_sha1("HEAD", head))
                        die (_("You do not have a valid HEAD"));
                if (index_differs_from("HEAD", 0))

-                       die_dirty_index(me);
+                       die_dirty_index(opts);

        }
        discard_cache();
 
        }
        discard_cache();
 


@@ -389,32 +408,32 @@ static int do_pick_commit(struct commit *commit)
                int cnt;
                struct commit_list *p;
 
                int cnt;
                struct commit_list *p;
 

-               if (!mainline)
+               if (!opts->mainline)

                        die(_("Commit %s is a merge but no -m option was given."),
                            sha1_to_hex(commit->object.sha1));
 
                for (cnt = 1, p = commit->parents;
                        die(_("Commit %s is a merge but no -m option was given."),
                            sha1_to_hex(commit->object.sha1));
 
                for (cnt = 1, p = commit->parents;

-                    cnt != mainline && p;
+                    cnt != opts->mainline && p;

                     cnt++)
                        p = p->next;
                     cnt++)
                        p = p->next;

-               if (cnt != mainline || !p)
+               if (cnt != opts->mainline || !p)

                        die(_("Commit %s does not have parent %d"),
                        die(_("Commit %s does not have parent %d"),

-                           sha1_to_hex(commit->object.sha1), mainline);
+                           sha1_to_hex(commit->object.sha1), opts->mainline);

                parent = p->item;
                parent = p->item;

-       } else if (0 < mainline)
+       } else if (0 < opts->mainline)

                die(_("Mainline was specified but commit %s is not a merge."),
                    sha1_to_hex(commit->object.sha1));
        else
                parent = commit->parents->item;
 
                die(_("Mainline was specified but commit %s is not a merge."),
                    sha1_to_hex(commit->object.sha1));
        else
                parent = commit->parents->item;
 

-       if (allow_ff && parent && !hashcmp(parent->object.sha1, head))
+       if (opts->allow_ff && parent && !hashcmp(parent->object.sha1, head))

                return fast_forward_to(commit->object.sha1, head);
 
        if (parent && parse_commit(parent) < 0)
                /* TRANSLATORS: The first %s will be "revert" or
                   "cherry-pick", the second %s a SHA1 */
                die(_("%s: cannot parse parent commit %s"),
                return fast_forward_to(commit->object.sha1, head);
 
        if (parent && parse_commit(parent) < 0)
                /* TRANSLATORS: The first %s will be "revert" or
                   "cherry-pick", the second %s a SHA1 */
                die(_("%s: cannot parse parent commit %s"),

-                   me, sha1_to_hex(parent->object.sha1));
+                   action_name(opts), sha1_to_hex(parent->object.sha1));

 
        if (get_message(commit, &msg) != 0)
                die(_("Cannot get commit message for %s"),
 
        if (get_message(commit, &msg) != 0)
                die(_("Cannot get commit message for %s"),


@@ -429,7 +448,7 @@ static int do_pick_commit(struct commit *commit)
 
        defmsg = git_pathdup("MERGE_MSG");
 
 
        defmsg = git_pathdup("MERGE_MSG");
 

-       if (action == REVERT) {
+       if (opts->action == REVERT) {

                base = commit;
                base_label = msg.label;
                next = parent;
                base = commit;
                base_label = msg.label;
                next = parent;


@@ -463,18 +482,18 @@ static int do_pick_commit(struct commit *commit)
                        strbuf_addstr(&msgbuf, p);
                }
 
                        strbuf_addstr(&msgbuf, p);
                }
 

-               if (record_origin) {
+               if (opts->record_origin) {

                        strbuf_addstr(&msgbuf, "(cherry picked from commit ");
                        strbuf_addstr(&msgbuf, sha1_to_hex(commit->object.sha1));
                        strbuf_addstr(&msgbuf, ")\n");
                }
                        strbuf_addstr(&msgbuf, "(cherry picked from commit ");
                        strbuf_addstr(&msgbuf, sha1_to_hex(commit->object.sha1));
                        strbuf_addstr(&msgbuf, ")\n");
                }

-               if (!no_commit)
+               if (!opts->no_commit)

                        write_cherry_pick_head(commit);
        }
 
                        write_cherry_pick_head(commit);
        }
 

-       if (!strategy || !strcmp(strategy, "recursive") || action == REVERT) {
+       if (!opts->strategy || !strcmp(opts->strategy, "recursive") || opts->action == REVERT) {

                res = do_recursive_merge(base, next, base_label, next_label,
                res = do_recursive_merge(base, next, base_label, next_label,

-                                        head, &msgbuf);
+                                        head, &msgbuf, opts);

                write_message(&msgbuf, defmsg);
        } else {
                struct commit_list *common = NULL;
                write_message(&msgbuf, defmsg);
        } else {
                struct commit_list *common = NULL;


@@ -484,23 +503,23 @@ static int do_pick_commit(struct commit *commit)
 
                commit_list_insert(base, &common);
                commit_list_insert(next, &remotes);
 
                commit_list_insert(base, &common);
                commit_list_insert(next, &remotes);

-               res = try_merge_command(strategy, xopts_nr, xopts, common,
-                                       sha1_to_hex(head), remotes);
+               res = try_merge_command(opts->strategy, opts->xopts_nr, opts->xopts,
+                                       common, sha1_to_hex(head), remotes);

                free_commit_list(common);
                free_commit_list(remotes);
        }
 
        if (res) {
                free_commit_list(common);
                free_commit_list(remotes);
        }
 
        if (res) {

-               error(action == REVERT
+               error(opts->action == REVERT

                      ? _("could not revert %s... %s")
                      : _("could not apply %s... %s"),
                      find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV),
                      msg.subject);
                print_advice();
                      ? _("could not revert %s... %s")
                      : _("could not apply %s... %s"),
                      find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV),
                      msg.subject);
                print_advice();

-               rerere(allow_rerere_auto);
+               rerere(opts->allow_rerere_auto);

        } else {
        } else {

-               if (!no_commit)
-                       res = run_git_commit(defmsg);
+               if (!opts->no_commit)
+                       res = run_git_commit(defmsg, opts);

        }
 
        free_message(&msg);
        }
 
        free_message(&msg);


@@ -509,18 +528,18 @@ static int do_pick_commit(struct commit *commit)
        return res;
 }
 
        return res;
 }
 

-static void prepare_revs(struct rev_info *revs)
+static void prepare_revs(struct rev_info *revs, struct replay_opts *opts)

 {
        int argc;
 
        init_revisions(revs, NULL);
        revs->no_walk = 1;
 {
        int argc;
 
        init_revisions(revs, NULL);
        revs->no_walk = 1;

-       if (action != REVERT)
+       if (opts->action != REVERT)

                revs->reverse = 1;
 
                revs->reverse = 1;
 

-       argc = setup_revisions(commit_argc, commit_argv, revs, NULL);
+       argc = setup_revisions(opts->commit_argc, opts->commit_argv, revs, NULL);

        if (argc > 1)
        if (argc > 1)

-               usage(*revert_or_cherry_pick_usage());
+               usage(*revert_or_cherry_pick_usage(opts));

 
        if (prepare_revision_walk(revs))
                die(_("revision walk setup failed"));
 
        if (prepare_revision_walk(revs))
                die(_("revision walk setup failed"));


@@ -529,48 +548,48 @@ static void prepare_revs(struct rev_info *revs)
                die(_("empty commit set passed"));
 }
 
                die(_("empty commit set passed"));
 }
 

-static void read_and_refresh_cache(const char *me)
+static void read_and_refresh_cache(struct replay_opts *opts)

 {
        static struct lock_file index_lock;
        int index_fd = hold_locked_index(&index_lock, 0);
        if (read_index_preload(&the_index, NULL) < 0)
 {
        static struct lock_file index_lock;
        int index_fd = hold_locked_index(&index_lock, 0);
        if (read_index_preload(&the_index, NULL) < 0)

-               die(_("git %s: failed to read the index"), me);
+               die(_("git %s: failed to read the index"), action_name(opts));

        refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
        if (the_index.cache_changed) {
                if (write_index(&the_index, index_fd) ||
                    commit_locked_index(&index_lock))
        refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
        if (the_index.cache_changed) {
                if (write_index(&the_index, index_fd) ||
                    commit_locked_index(&index_lock))

-                       die(_("git %s: failed to refresh the index"), me);
+                       die(_("git %s: failed to refresh the index"), action_name(opts));

        }
        rollback_lock_file(&index_lock);
 }
 
        }
        rollback_lock_file(&index_lock);
 }
 

-static int revert_or_cherry_pick(int argc, const char **argv)
+static int revert_or_cherry_pick(int argc, const char **argv,
+                               struct replay_opts *opts)

 {
        struct rev_info revs;
        struct commit *commit;
 
        git_config(git_default_config, NULL);
 {
        struct rev_info revs;
        struct commit *commit;
 
        git_config(git_default_config, NULL);

-       me = action == REVERT ? "revert" : "cherry-pick";
-       setenv(GIT_REFLOG_ACTION, me, 0);
-       parse_args(argc, argv);
+       setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
+       parse_args(argc, argv, opts);

 
 

-       if (allow_ff) {
-               if (signoff)
+       if (opts->allow_ff) {
+               if (opts->signoff)

                        die(_("cherry-pick --ff cannot be used with --signoff"));
                        die(_("cherry-pick --ff cannot be used with --signoff"));

-               if (no_commit)
+               if (opts->no_commit)

                        die(_("cherry-pick --ff cannot be used with --no-commit"));
                        die(_("cherry-pick --ff cannot be used with --no-commit"));

-               if (record_origin)
+               if (opts->record_origin)

                        die(_("cherry-pick --ff cannot be used with -x"));
                        die(_("cherry-pick --ff cannot be used with -x"));

-               if (edit)
+               if (opts->edit)

                        die(_("cherry-pick --ff cannot be used with --edit"));
        }
 
                        die(_("cherry-pick --ff cannot be used with --edit"));
        }
 

-       read_and_refresh_cache(me);
+       read_and_refresh_cache(opts);

 
 

-       prepare_revs(&revs);
+       prepare_revs(&revs, opts);

 
        while ((commit = get_revision(&revs))) {
 
        while ((commit = get_revision(&revs))) {

-               int res = do_pick_commit(commit);
+               int res = do_pick_commit(commit, opts);

                if (res)
                        return res;
        }
                if (res)
                        return res;
        }


@@ -580,14 +599,20 @@ static int revert_or_cherry_pick(int argc, const char **argv)
 
 int cmd_revert(int argc, const char **argv, const char *prefix)
 {
 
 int cmd_revert(int argc, const char **argv, const char *prefix)
 {

+       struct replay_opts opts;
+
+       memset(&opts, 0, sizeof(opts));

        if (isatty(0))
        if (isatty(0))

-               edit = 1;
-       action = REVERT;
-       return revert_or_cherry_pick(argc, argv);
+               opts.edit = 1;
+       opts.action = REVERT;
+       return revert_or_cherry_pick(argc, argv, &opts);

 }
 
 int cmd_cherry_pick(int argc, const char **argv, const char *prefix)
 {
 }
 
 int cmd_cherry_pick(int argc, const char **argv, const char *prefix)
 {

-       action = CHERRY_PICK;
-       return revert_or_cherry_pick(argc, argv);
+       struct replay_opts opts;
+
+       memset(&opts, 0, sizeof(opts));
+       opts.action = CHERRY_PICK;
+       return revert_or_cherry_pick(argc, argv, &opts);

 }
 }