Merge branch 'jk/unused-params-final-batch'
authorJunio C Hamano <gitster@pobox.com>
Thu, 13 Jun 2019 20:19:34 +0000 (13:19 -0700)
committerJunio C Hamano <gitster@pobox.com>
Thu, 13 Jun 2019 20:19:34 +0000 (13:19 -0700)
* jk/unused-params-final-batch:
  verify-commit: simplify parameters to run_gpg_verify()
  show-branch: drop unused parameter from show_independent()
  rev-list: drop unused void pointer from finish_commit()
  remove_all_fetch_refspecs(): drop unused "remote" parameter
  receive-pack: drop unused "commands" from prepare_shallow_update()
  pack-objects: drop unused rev_info parameters
  name-rev: drop unused parameters from is_better_name()
  mktree: drop unused length parameter
  wt-status: drop unused status parameter
  read-cache: drop unused parameter from threaded load
  clone: drop dest parameter from copy_alternates()
  submodule: drop unused prefix parameter from some functions
  builtin: consistently pass cmd_* prefix to parse_options
  cmd_{read,write}_tree: rename "unused" variable that is used

1  2 
builtin/clone.c
builtin/pack-objects.c
builtin/rebase.c
builtin/submodule--helper.c
read-cache.c
wt-status.c

diff --cc builtin/clone.c
Simple merge
Simple merge
@@@ -90,437 -86,6 +90,437 @@@ struct rebase_options 
        int use_legacy_rebase;
  };
  
-       argc = parse_options(argc, argv, NULL, options,
 +#define REBASE_OPTIONS_INIT {                         \
 +              .type = REBASE_UNSPECIFIED,             \
 +              .flags = REBASE_NO_QUIET,               \
 +              .git_am_opts = ARGV_ARRAY_INIT,         \
 +              .git_format_patch_opt = STRBUF_INIT     \
 +      }
 +
 +static struct replay_opts get_replay_opts(const struct rebase_options *opts)
 +{
 +      struct replay_opts replay = REPLAY_OPTS_INIT;
 +
 +      replay.action = REPLAY_INTERACTIVE_REBASE;
 +      sequencer_init_config(&replay);
 +
 +      replay.signoff = opts->signoff;
 +      replay.allow_ff = !(opts->flags & REBASE_FORCE);
 +      if (opts->allow_rerere_autoupdate)
 +              replay.allow_rerere_auto = opts->allow_rerere_autoupdate;
 +      replay.allow_empty = 1;
 +      replay.allow_empty_message = opts->allow_empty_message;
 +      replay.verbose = opts->flags & REBASE_VERBOSE;
 +      replay.reschedule_failed_exec = opts->reschedule_failed_exec;
 +      replay.gpg_sign = xstrdup_or_null(opts->gpg_sign_opt);
 +      replay.strategy = opts->strategy;
 +      if (opts->strategy_opts)
 +              parse_strategy_opts(&replay, opts->strategy_opts);
 +
 +      return replay;
 +}
 +
 +enum action {
 +      ACTION_NONE = 0,
 +      ACTION_CONTINUE,
 +      ACTION_SKIP,
 +      ACTION_ABORT,
 +      ACTION_QUIT,
 +      ACTION_EDIT_TODO,
 +      ACTION_SHOW_CURRENT_PATCH,
 +      ACTION_SHORTEN_OIDS,
 +      ACTION_EXPAND_OIDS,
 +      ACTION_CHECK_TODO_LIST,
 +      ACTION_REARRANGE_SQUASH,
 +      ACTION_ADD_EXEC
 +};
 +
 +static const char *action_names[] = { "undefined",
 +                                    "continue",
 +                                    "skip",
 +                                    "abort",
 +                                    "quit",
 +                                    "edit_todo",
 +                                    "show_current_patch" };
 +
 +static int add_exec_commands(struct string_list *commands)
 +{
 +      const char *todo_file = rebase_path_todo();
 +      struct todo_list todo_list = TODO_LIST_INIT;
 +      int res;
 +
 +      if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
 +              return error_errno(_("could not read '%s'."), todo_file);
 +
 +      if (todo_list_parse_insn_buffer(the_repository, todo_list.buf.buf,
 +                                      &todo_list)) {
 +              todo_list_release(&todo_list);
 +              return error(_("unusable todo list: '%s'"), todo_file);
 +      }
 +
 +      todo_list_add_exec_commands(&todo_list, commands);
 +      res = todo_list_write_to_file(the_repository, &todo_list,
 +                                    todo_file, NULL, NULL, -1, 0);
 +      todo_list_release(&todo_list);
 +
 +      if (res)
 +              return error_errno(_("could not write '%s'."), todo_file);
 +      return 0;
 +}
 +
 +static int rearrange_squash_in_todo_file(void)
 +{
 +      const char *todo_file = rebase_path_todo();
 +      struct todo_list todo_list = TODO_LIST_INIT;
 +      int res = 0;
 +
 +      if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
 +              return error_errno(_("could not read '%s'."), todo_file);
 +      if (todo_list_parse_insn_buffer(the_repository, todo_list.buf.buf,
 +                                      &todo_list)) {
 +              todo_list_release(&todo_list);
 +              return error(_("unusable todo list: '%s'"), todo_file);
 +      }
 +
 +      res = todo_list_rearrange_squash(&todo_list);
 +      if (!res)
 +              res = todo_list_write_to_file(the_repository, &todo_list,
 +                                            todo_file, NULL, NULL, -1, 0);
 +
 +      todo_list_release(&todo_list);
 +
 +      if (res)
 +              return error_errno(_("could not write '%s'."), todo_file);
 +      return 0;
 +}
 +
 +static int transform_todo_file(unsigned flags)
 +{
 +      const char *todo_file = rebase_path_todo();
 +      struct todo_list todo_list = TODO_LIST_INIT;
 +      int res;
 +
 +      if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
 +              return error_errno(_("could not read '%s'."), todo_file);
 +
 +      if (todo_list_parse_insn_buffer(the_repository, todo_list.buf.buf,
 +                                      &todo_list)) {
 +              todo_list_release(&todo_list);
 +              return error(_("unusable todo list: '%s'"), todo_file);
 +      }
 +
 +      res = todo_list_write_to_file(the_repository, &todo_list, todo_file,
 +                                    NULL, NULL, -1, flags);
 +      todo_list_release(&todo_list);
 +
 +      if (res)
 +              return error_errno(_("could not write '%s'."), todo_file);
 +      return 0;
 +}
 +
 +static int edit_todo_file(unsigned flags)
 +{
 +      const char *todo_file = rebase_path_todo();
 +      struct todo_list todo_list = TODO_LIST_INIT,
 +              new_todo = TODO_LIST_INIT;
 +      int res = 0;
 +
 +      if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
 +              return error_errno(_("could not read '%s'."), todo_file);
 +
 +      strbuf_stripspace(&todo_list.buf, 1);
 +      res = edit_todo_list(the_repository, &todo_list, &new_todo, NULL, NULL, flags);
 +      if (!res && todo_list_write_to_file(the_repository, &new_todo, todo_file,
 +                                          NULL, NULL, -1, flags & ~(TODO_LIST_SHORTEN_IDS)))
 +              res = error_errno(_("could not write '%s'"), todo_file);
 +
 +      todo_list_release(&todo_list);
 +      todo_list_release(&new_todo);
 +
 +      return res;
 +}
 +
 +static int get_revision_ranges(struct commit *upstream, struct commit *onto,
 +                             const char **head_hash,
 +                             char **revisions, char **shortrevisions)
 +{
 +      struct commit *base_rev = upstream ? upstream : onto;
 +      const char *shorthead;
 +      struct object_id orig_head;
 +
 +      if (get_oid("HEAD", &orig_head))
 +              return error(_("no HEAD?"));
 +
 +      *head_hash = find_unique_abbrev(&orig_head, GIT_MAX_HEXSZ);
 +      *revisions = xstrfmt("%s...%s", oid_to_hex(&base_rev->object.oid),
 +                                                 *head_hash);
 +
 +      shorthead = find_unique_abbrev(&orig_head, DEFAULT_ABBREV);
 +
 +      if (upstream) {
 +              const char *shortrev;
 +
 +              shortrev = find_unique_abbrev(&base_rev->object.oid,
 +                                            DEFAULT_ABBREV);
 +
 +              *shortrevisions = xstrfmt("%s..%s", shortrev, shorthead);
 +      } else
 +              *shortrevisions = xstrdup(shorthead);
 +
 +      return 0;
 +}
 +
 +static int init_basic_state(struct replay_opts *opts, const char *head_name,
 +                          struct commit *onto, const char *orig_head)
 +{
 +      FILE *interactive;
 +
 +      if (!is_directory(merge_dir()) && mkdir_in_gitdir(merge_dir()))
 +              return error_errno(_("could not create temporary %s"), merge_dir());
 +
 +      delete_reflog("REBASE_HEAD");
 +
 +      interactive = fopen(path_interactive(), "w");
 +      if (!interactive)
 +              return error_errno(_("could not mark as interactive"));
 +      fclose(interactive);
 +
 +      return write_basic_state(opts, head_name, onto, orig_head);
 +}
 +
 +static void split_exec_commands(const char *cmd, struct string_list *commands)
 +{
 +      if (cmd && *cmd) {
 +              string_list_split(commands, cmd, '\n', -1);
 +
 +              /* rebase.c adds a new line to cmd after every command,
 +               * so here the last command is always empty */
 +              string_list_remove_empty_items(commands, 0);
 +      }
 +}
 +
 +static int do_interactive_rebase(struct rebase_options *opts, unsigned flags)
 +{
 +      int ret;
 +      const char *head_hash = NULL;
 +      char *revisions = NULL, *shortrevisions = NULL;
 +      struct argv_array make_script_args = ARGV_ARRAY_INIT;
 +      struct todo_list todo_list = TODO_LIST_INIT;
 +      struct replay_opts replay = get_replay_opts(opts);
 +      struct string_list commands = STRING_LIST_INIT_DUP;
 +
 +      if (prepare_branch_to_be_rebased(the_repository, &replay,
 +                                       opts->switch_to))
 +              return -1;
 +
 +      if (get_revision_ranges(opts->upstream, opts->onto, &head_hash,
 +                              &revisions, &shortrevisions))
 +              return -1;
 +
 +      if (init_basic_state(&replay,
 +                           opts->head_name ? opts->head_name : "detached HEAD",
 +                           opts->onto, head_hash)) {
 +              free(revisions);
 +              free(shortrevisions);
 +
 +              return -1;
 +      }
 +
 +      if (!opts->upstream && opts->squash_onto)
 +              write_file(path_squash_onto(), "%s\n",
 +                         oid_to_hex(opts->squash_onto));
 +
 +      argv_array_pushl(&make_script_args, "", revisions, NULL);
 +      if (opts->restrict_revision)
 +              argv_array_push(&make_script_args,
 +                              oid_to_hex(&opts->restrict_revision->object.oid));
 +
 +      ret = sequencer_make_script(the_repository, &todo_list.buf,
 +                                  make_script_args.argc, make_script_args.argv,
 +                                  flags);
 +
 +      if (ret)
 +              error(_("could not generate todo list"));
 +      else {
 +              discard_cache();
 +              if (todo_list_parse_insn_buffer(the_repository, todo_list.buf.buf,
 +                                              &todo_list))
 +                      BUG("unusable todo list");
 +
 +              split_exec_commands(opts->cmd, &commands);
 +              ret = complete_action(the_repository, &replay, flags,
 +                      shortrevisions, opts->onto_name, opts->onto, head_hash,
 +                      &commands, opts->autosquash, &todo_list);
 +      }
 +
 +      string_list_clear(&commands, 0);
 +      free(revisions);
 +      free(shortrevisions);
 +      todo_list_release(&todo_list);
 +      argv_array_clear(&make_script_args);
 +
 +      return ret;
 +}
 +
 +static int run_rebase_interactive(struct rebase_options *opts,
 +                                enum action command)
 +{
 +      unsigned flags = 0;
 +      int abbreviate_commands = 0, ret = 0;
 +
 +      git_config_get_bool("rebase.abbreviatecommands", &abbreviate_commands);
 +
 +      flags |= opts->keep_empty ? TODO_LIST_KEEP_EMPTY : 0;
 +      flags |= abbreviate_commands ? TODO_LIST_ABBREVIATE_CMDS : 0;
 +      flags |= opts->rebase_merges ? TODO_LIST_REBASE_MERGES : 0;
 +      flags |= opts->rebase_cousins > 0 ? TODO_LIST_REBASE_COUSINS : 0;
 +      flags |= command == ACTION_SHORTEN_OIDS ? TODO_LIST_SHORTEN_IDS : 0;
 +
 +      switch (command) {
 +      case ACTION_NONE: {
 +              if (!opts->onto && !opts->upstream)
 +                      die(_("a base commit must be provided with --upstream or --onto"));
 +
 +              ret = do_interactive_rebase(opts, flags);
 +              break;
 +      }
 +      case ACTION_SKIP: {
 +              struct string_list merge_rr = STRING_LIST_INIT_DUP;
 +
 +              rerere_clear(the_repository, &merge_rr);
 +      }
 +              /* fallthrough */
 +      case ACTION_CONTINUE: {
 +              struct replay_opts replay_opts = get_replay_opts(opts);
 +
 +              ret = sequencer_continue(the_repository, &replay_opts);
 +              break;
 +      }
 +      case ACTION_EDIT_TODO:
 +              ret = edit_todo_file(flags);
 +              break;
 +      case ACTION_SHOW_CURRENT_PATCH: {
 +              struct child_process cmd = CHILD_PROCESS_INIT;
 +
 +              cmd.git_cmd = 1;
 +              argv_array_pushl(&cmd.args, "show", "REBASE_HEAD", "--", NULL);
 +              ret = run_command(&cmd);
 +
 +              break;
 +      }
 +      case ACTION_SHORTEN_OIDS:
 +      case ACTION_EXPAND_OIDS:
 +              ret = transform_todo_file(flags);
 +              break;
 +      case ACTION_CHECK_TODO_LIST:
 +              ret = check_todo_list_from_file(the_repository);
 +              break;
 +      case ACTION_REARRANGE_SQUASH:
 +              ret = rearrange_squash_in_todo_file();
 +              break;
 +      case ACTION_ADD_EXEC: {
 +              struct string_list commands = STRING_LIST_INIT_DUP;
 +
 +              split_exec_commands(opts->cmd, &commands);
 +              ret = add_exec_commands(&commands);
 +              string_list_clear(&commands, 0);
 +              break;
 +      }
 +      default:
 +              BUG("invalid command '%d'", command);
 +      }
 +
 +      return ret;
 +}
 +
 +static const char * const builtin_rebase_interactive_usage[] = {
 +      N_("git rebase--interactive [<options>]"),
 +      NULL
 +};
 +
 +int cmd_rebase__interactive(int argc, const char **argv, const char *prefix)
 +{
 +      struct rebase_options opts = REBASE_OPTIONS_INIT;
 +      struct object_id squash_onto = null_oid;
 +      enum action command = ACTION_NONE;
 +      struct option options[] = {
 +              OPT_NEGBIT(0, "ff", &opts.flags, N_("allow fast-forward"),
 +                         REBASE_FORCE),
 +              OPT_BOOL(0, "keep-empty", &opts.keep_empty, N_("keep empty commits")),
 +              OPT_BOOL(0, "allow-empty-message", &opts.allow_empty_message,
 +                       N_("allow commits with empty messages")),
 +              OPT_BOOL(0, "rebase-merges", &opts.rebase_merges, N_("rebase merge commits")),
 +              OPT_BOOL(0, "rebase-cousins", &opts.rebase_cousins,
 +                       N_("keep original branch points of cousins")),
 +              OPT_BOOL(0, "autosquash", &opts.autosquash,
 +                       N_("move commits that begin with squash!/fixup!")),
 +              OPT_BOOL(0, "signoff", &opts.signoff, N_("sign commits")),
 +              OPT_BIT('v', "verbose", &opts.flags,
 +                      N_("display a diffstat of what changed upstream"),
 +                      REBASE_NO_QUIET | REBASE_VERBOSE | REBASE_DIFFSTAT),
 +              OPT_CMDMODE(0, "continue", &command, N_("continue rebase"),
 +                          ACTION_CONTINUE),
 +              OPT_CMDMODE(0, "skip", &command, N_("skip commit"), ACTION_SKIP),
 +              OPT_CMDMODE(0, "edit-todo", &command, N_("edit the todo list"),
 +                          ACTION_EDIT_TODO),
 +              OPT_CMDMODE(0, "show-current-patch", &command, N_("show the current patch"),
 +                          ACTION_SHOW_CURRENT_PATCH),
 +              OPT_CMDMODE(0, "shorten-ids", &command,
 +                      N_("shorten commit ids in the todo list"), ACTION_SHORTEN_OIDS),
 +              OPT_CMDMODE(0, "expand-ids", &command,
 +                      N_("expand commit ids in the todo list"), ACTION_EXPAND_OIDS),
 +              OPT_CMDMODE(0, "check-todo-list", &command,
 +                      N_("check the todo list"), ACTION_CHECK_TODO_LIST),
 +              OPT_CMDMODE(0, "rearrange-squash", &command,
 +                      N_("rearrange fixup/squash lines"), ACTION_REARRANGE_SQUASH),
 +              OPT_CMDMODE(0, "add-exec-commands", &command,
 +                      N_("insert exec commands in todo list"), ACTION_ADD_EXEC),
 +              { OPTION_CALLBACK, 0, "onto", &opts.onto, N_("onto"), N_("onto"),
 +                PARSE_OPT_NONEG, parse_opt_commit, 0 },
 +              { OPTION_CALLBACK, 0, "restrict-revision", &opts.restrict_revision,
 +                N_("restrict-revision"), N_("restrict revision"),
 +                PARSE_OPT_NONEG, parse_opt_commit, 0 },
 +              { OPTION_CALLBACK, 0, "squash-onto", &squash_onto, N_("squash-onto"),
 +                N_("squash onto"), PARSE_OPT_NONEG, parse_opt_object_id, 0 },
 +              { OPTION_CALLBACK, 0, "upstream", &opts.upstream, N_("upstream"),
 +                N_("the upstream commit"), PARSE_OPT_NONEG, parse_opt_commit,
 +                0 },
 +              OPT_STRING(0, "head-name", &opts.head_name, N_("head-name"), N_("head name")),
 +              { OPTION_STRING, 'S', "gpg-sign", &opts.gpg_sign_opt, N_("key-id"),
 +                      N_("GPG-sign commits"),
 +                      PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
 +              OPT_STRING(0, "strategy", &opts.strategy, N_("strategy"),
 +                         N_("rebase strategy")),
 +              OPT_STRING(0, "strategy-opts", &opts.strategy_opts, N_("strategy-opts"),
 +                         N_("strategy options")),
 +              OPT_STRING(0, "switch-to", &opts.switch_to, N_("switch-to"),
 +                         N_("the branch or commit to checkout")),
 +              OPT_STRING(0, "onto-name", &opts.onto_name, N_("onto-name"), N_("onto name")),
 +              OPT_STRING(0, "cmd", &opts.cmd, N_("cmd"), N_("the command to run")),
 +              OPT_RERERE_AUTOUPDATE(&opts.allow_rerere_autoupdate),
 +              OPT_BOOL(0, "reschedule-failed-exec", &opts.reschedule_failed_exec,
 +                       N_("automatically re-schedule any `exec` that fails")),
 +              OPT_END()
 +      };
 +
 +      opts.rebase_cousins = -1;
 +
 +      if (argc == 1)
 +              usage_with_options(builtin_rebase_interactive_usage, options);
 +
++      argc = parse_options(argc, argv, prefix, options,
 +                      builtin_rebase_interactive_usage, PARSE_OPT_KEEP_ARGV0);
 +
 +      if (!is_null_oid(&squash_onto))
 +              opts.squash_onto = &squash_onto;
 +
 +      if (opts.rebase_cousins >= 0 && !opts.rebase_merges)
 +              warning(_("--[no-]rebase-cousins has no effect without "
 +                        "--rebase-merges"));
 +
 +      return !!run_rebase_interactive(&opts, command);
 +}
 +
  static int is_interactive(struct rebase_options *opts)
  {
        return opts->type == REBASE_INTERACTIVE ||
Simple merge
diff --cc read-cache.c
Simple merge
diff --cc wt-status.c
Simple merge