Merge branch 'nd/diff-parseopt-4'
authorJunio C Hamano <gitster@pobox.com>
Thu, 25 Apr 2019 07:41:12 +0000 (16:41 +0900)
committerJunio C Hamano <gitster@pobox.com>
Thu, 25 Apr 2019 07:41:12 +0000 (16:41 +0900)
Fourth batch to teach the diff machinery to use the parse-options
API.

* nd/diff-parseopt-4:
am: avoid diff_opt_parse()
diff --no-index: use parse_options() instead of diff_opt_parse()
range-diff: use parse_options() instead of diff_opt_parse()
diff.c: allow --no-color-moved-ws
diff-parseopt: convert --color-moved-ws
diff-parseopt: convert --[no-]color-moved
diff-parseopt: convert --inter-hunk-context
diff-parseopt: convert --no-prefix
diff-parseopt: convert --line-prefix
diff-parseopt: convert --[src|dst]-prefix
diff-parseopt: convert --[no-]abbrev
diff-parseopt: convert --diff-filter
diff-parseopt: convert --find-object
diff-parseopt: convert -O
diff-parseopt: convert --pickaxe-all|--pickaxe-regex
diff-parseopt: convert -S|-G
diff-parseopt: convert -l
diff-parseopt: convert -z
diff-parseopt: convert --ita-[in]visible-in-index
diff-parseopt: convert --ws-error-highlight

1  2 
builtin/am.c
builtin/diff.c
diff-no-index.c
diff.c
diff.h
parse-options.h
t/t4053-diff-no-index.sh
diff --combined builtin/am.c
index 4fb107a9d1bdf36ff4c71d761abdda4d50d0e24b,0cbf285459c77c95ea6f1ba9111bedb4c41b3cfa..3ba5723c2c8ff9bf27e7d3fa8f03a79b37d2a89d
@@@ -3,7 -3,6 +3,7 @@@
   *
   * Based on git-am.sh by Junio C Hamano.
   */
 +#define USE_THE_INDEX_COMPATIBILITY_MACROS
  #include "cache.h"
  #include "config.h"
  #include "builtin.h"
  #include "packfile.h"
  #include "repository.h"
  
 -/**
 - * Returns 1 if the file is empty or does not exist, 0 otherwise.
 - */
 -static int is_empty_file(const char *filename)
 -{
 -      struct stat st;
 -
 -      if (stat(filename, &st) < 0) {
 -              if (errno == ENOENT)
 -                      return 1;
 -              die_errno(_("could not stat %s"), filename);
 -      }
 -
 -      return !st.st_size;
 -}
 -
  /**
   * Returns the length of the first line of msg.
   */
@@@ -453,7 -468,6 +453,7 @@@ static int run_post_rewrite_hook(const 
  
        cp.in = xopen(am_path(state, "rewritten"), O_RDONLY);
        cp.stdout_to_stderr = 1;
 +      cp.trace2_hook_name = "post-rewrite";
  
        ret = run_command(&cp);
  
@@@ -513,7 -527,7 +513,7 @@@ static int copy_notes_for_rebase(const 
        }
  
  finish:
 -      finish_copy_notes_for_rewrite(c, msg);
 +      finish_copy_notes_for_rewrite(the_repository, c, msg);
        fclose(fp);
        strbuf_release(&sb);
        return ret;
@@@ -1206,7 -1220,7 +1206,7 @@@ static int parse_mail(struct am_state *
                goto finish;
        }
  
 -      if (is_empty_file(am_path(state, "patch"))) {
 +      if (is_empty_or_missing_file(am_path(state, "patch"))) {
                printf_ln(_("Patch is empty."));
                die_user_resolve(state);
        }
@@@ -1501,11 -1515,11 +1501,11 @@@ static int fall_back_threeway(const str
                 * review them with extra care to spot mismerges.
                 */
                struct rev_info rev_info;
-               const char *diff_filter_str = "--diff-filter=AM";
  
                repo_init_revisions(the_repository, &rev_info, NULL);
                rev_info.diffopt.output_format = DIFF_FORMAT_NAME_STATUS;
-               diff_opt_parse(&rev_info.diffopt, &diff_filter_str, 1, rev_info.prefix);
+               rev_info.diffopt.filter |= diff_filter_bit('A');
+               rev_info.diffopt.filter |= diff_filter_bit('M');
                add_pending_oid(&rev_info, "HEAD", &our_tree, 0);
                diff_setup_done(&rev_info.diffopt);
                run_diff_index(&rev_info, 1);
         * changes.
         */
  
 -      init_merge_options(&o);
 +      init_merge_options(&o, the_repository);
  
        o.branch1 = "HEAD";
        their_tree_name = xstrfmt("%.*s", linelen(state->msg), state->msg);
@@@ -1580,7 -1594,6 +1580,7 @@@ static void do_commit(const struct am_s
        }
  
        author = fmt_ident(state->author_name, state->author_email,
 +              WANT_AUTHOR_IDENT,
                        state->ignore_date ? NULL : state->author_date,
                        IDENT_STRICT);
  
@@@ -1706,7 -1719,7 +1706,7 @@@ static void am_run(struct am_state *sta
  
        refresh_and_write_cache();
  
 -      if (index_has_changes(&the_index, NULL, &sb)) {
 +      if (repo_index_has_changes(the_repository, NULL, &sb)) {
                write_state_bool(state, "dirtyindex", 1);
                die(_("Dirty index: cannot apply patches (dirty: %s)"), sb.buf);
        }
                         * the result may have produced the same tree as ours.
                         */
                        if (!apply_status &&
 -                          !index_has_changes(&the_index, NULL, NULL)) {
 +                          !repo_index_has_changes(the_repository, NULL, NULL)) {
                                say(state, stdout, _("No changes -- Patch already applied."));
                                goto next;
                        }
@@@ -1790,7 -1803,7 +1790,7 @@@ next
                resume = 0;
        }
  
 -      if (!is_empty_file(am_path(state, "rewritten"))) {
 +      if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
                assert(state->rebasing);
                copy_notes_for_rebase(state);
                run_post_rewrite_hook(state);
@@@ -1818,7 -1831,7 +1818,7 @@@ static void am_resolve(struct am_state 
  
        say(state, stdout, _("Applying: %.*s"), linelen(state->msg), state->msg);
  
 -      if (!index_has_changes(&the_index, NULL, NULL)) {
 +      if (!repo_index_has_changes(the_repository, NULL, NULL)) {
                printf_ln(_("No changes - did you forget to use 'git add'?\n"
                        "If there is nothing left to stage, chances are that something else\n"
                        "already introduced the same changes; you might want to skip this patch."));
@@@ -1987,15 -2000,6 +1987,15 @@@ static void am_skip(struct am_state *st
        if (clean_index(&head, &head))
                die(_("failed to clean index"));
  
 +      if (state->rebasing) {
 +              FILE *fp = xfopen(am_path(state, "rewritten"), "a");
 +
 +              assert(!is_null_oid(&state->orig_commit));
 +              fprintf(fp, "%s ", oid_to_hex(&state->orig_commit));
 +              fprintf(fp, "%s\n", oid_to_hex(&head));
 +              fclose(fp);
 +      }
 +
        am_next(state);
        am_load(state);
        am_run(state, 0);
@@@ -2121,10 -2125,6 +2121,10 @@@ static int parse_opt_patchformat(const 
                *opt_value = PATCH_FORMAT_HG;
        else if (!strcmp(arg, "mboxrd"))
                *opt_value = PATCH_FORMAT_MBOXRD;
 +      /*
 +       * Please update $__git_patchformat in git-completion.bash
 +       * when you add new options
 +       */
        else
                return error(_("Invalid value for --patch-format: %s"), arg);
        return 0;
@@@ -2278,7 -2278,7 +2278,7 @@@ int cmd_am(int argc, const char **argv
        /* Ensure a valid committer ident can be constructed */
        git_committer_info(IDENT_STRICT);
  
 -      if (read_index_preload(&the_index, NULL, 0) < 0)
 +      if (repo_read_index_preload(the_repository, NULL, 0) < 0)
                die(_("failed to read the index"));
  
        if (in_progress) {
diff --combined builtin/diff.c
index 53d4234ff4812845459556b1257e779c528250b8,52dc3e136f60bd72e5faff8ac626adccf0dfd8e8..42ac803091e6a0c7e22203b097d1f0001c9f5302
@@@ -3,7 -3,6 +3,7 @@@
   *
   * Copyright (c) 2006 Junio C Hamano
   */
 +#define USE_THE_INDEX_COMPATIBILITY_MACROS
  #include "cache.h"
  #include "config.h"
  #include "lockfile.h"
@@@ -103,7 -102,7 +103,7 @@@ static int builtin_diff_blobs(struct re
                              int argc, const char **argv,
                              struct object_array_entry **blob)
  {
 -      unsigned mode = canon_mode(S_IFREG | 0644);
 +      const unsigned mode = canon_mode(S_IFREG | 0644);
  
        if (argc > 1)
                usage(builtin_diff_usage);
@@@ -213,7 -212,7 +213,7 @@@ static void refresh_index_quietly(void
        discard_cache();
        read_cache();
        refresh_cache(REFRESH_QUIET|REFRESH_UNMERGED);
 -      update_index_if_able(&the_index, &lock_file);
 +      repo_update_index_if_able(the_repository, &lock_file);
  }
  
  static int builtin_diff_files(struct rev_info *revs, int argc, const char **argv)
@@@ -321,40 -320,23 +321,24 @@@ int cmd_diff(int argc, const char **arg
  
        repo_init_revisions(the_repository, &rev, prefix);
  
-       if (no_index && argc != i + 2) {
-               if (no_index == DIFF_NO_INDEX_IMPLICIT) {
-                       /*
-                        * There was no --no-index and there were not two
-                        * paths. It is possible that the user intended
-                        * to do an inside-repository operation.
-                        */
-                       fprintf(stderr, "Not a git repository\n");
-                       fprintf(stderr,
-                               "To compare two paths outside a working tree:\n");
-               }
-               /* Give the usage message for non-repository usage and exit. */
-               usagef("git diff %s <path> <path>",
-                      no_index == DIFF_NO_INDEX_EXPLICIT ?
-                      "--no-index" : "[--no-index]");
 -      if (no_index)
 -              /* If this is a no-index diff, just run it and exit there. */
 -              exit(diff_no_index(the_repository, &rev,
 -                                 no_index == DIFF_NO_INDEX_IMPLICIT,
 -                                 argc, argv));
--
-       }
 -      /* Otherwise, we are doing the usual "git" diff */
 -      rev.diffopt.skip_stat_unmatch = !!diff_auto_refresh_index;
--
 -      /* Scale to real terminal size and respect statGraphWidth config */
 +      /* Set up defaults that will apply to both no-index and regular diffs. */
        rev.diffopt.stat_width = -1;
        rev.diffopt.stat_graph_width = -1;
 -
 -      /* Default to let external and textconv be used */
        rev.diffopt.flags.allow_external = 1;
        rev.diffopt.flags.allow_textconv = 1;
  
-               diff_no_index(&rev, argc, argv);
 +      /* If this is a no-index diff, just run it and exit there. */
 +      if (no_index)
++              exit(diff_no_index(&rev, no_index == DIFF_NO_INDEX_IMPLICIT,
++                                 argc, argv));
++
 +
 +      /*
 +       * Otherwise, we are doing the usual "git" diff; set up any
 +       * further defaults that apply to regular diffs.
 +       */
 +      rev.diffopt.skip_stat_unmatch = !!diff_auto_refresh_index;
 +
        /*
         * Default to intent-to-add entries invisible in the
         * index. This makes them show up as new files in diff-files
diff --combined diff-no-index.c
index 6001baecd4c61ae22dd0aaec11bd4bc48a9152f8,a879f458627c3315ae72e39931084ac64e1b4d50..7814eabfe0289125fd50d4f3b0bba06fe08ccac4
@@@ -14,6 -14,7 +14,7 @@@
  #include "revision.h"
  #include "log-tree.h"
  #include "builtin.h"
+ #include "parse-options.h"
  #include "string-list.h"
  #include "dir.h"
  
@@@ -233,29 -234,43 +234,37 @@@ static void fixup_paths(const char **pa
        }
  }
  
- void diff_no_index(struct rev_info *revs,
-                  int argc, const char **argv)
+ static const char * const diff_no_index_usage[] = {
+       N_("git diff --no-index [<options>] <path> <path>"),
+       NULL
+ };
 -int diff_no_index(struct repository *r,
 -                struct rev_info *revs,
++int diff_no_index(struct rev_info *revs,
+                 int implicit_no_index,
+                 int argc, const char **argv)
  {
-       int i;
+       int i, no_index;
        const char *paths[2];
        struct strbuf replacement = STRBUF_INIT;
        const char *prefix = revs->prefix;
-       for (i = 1; i < argc - 2; ) {
-               int j;
-               if (!strcmp(argv[i], "--no-index"))
-                       i++;
-               else if (!strcmp(argv[i], "--"))
-                       i++;
-               else {
-                       j = diff_opt_parse(&revs->diffopt, argv + i, argc - i,
-                                          revs->prefix);
-                       if (j <= 0)
-                               die("invalid diff option/value: %s", argv[i]);
-                       i += j;
-               }
+       struct option no_index_options[] = {
+               OPT_BOOL_F(0, "no-index", &no_index, "",
+                          PARSE_OPT_NONEG | PARSE_OPT_HIDDEN),
+               OPT_END(),
+       };
+       struct option *options;
 -      /*
 -       * FIXME: --no-index should not look at index and we should be
 -       * able to pass NULL repo. Maybe later.
 -       */
 -      repo_diff_setup(r, &revs->diffopt);
+       options = parse_options_concat(no_index_options,
+                                      revs->diffopt.parseopts);
+       argc = parse_options(argc, argv, revs->prefix, options,
+                            diff_no_index_usage, 0);
+       if (argc != 2) {
+               if (implicit_no_index)
+                       warning(_("Not a git repository. Use --no-index to "
+                                 "compare two paths outside a working tree"));
+               usage_with_options(diff_no_index_usage, options);
        }
+       FREE_AND_NULL(options);
        for (i = 0; i < 2; i++) {
                const char *p = argv[argc - 2 + i];
                if (!strcmp(p, "-"))
        revs->diffopt.flags.exit_with_status = 1;
  
        if (queue_diff(&revs->diffopt, paths[0], paths[1]))
-               exit(1);
+               return 1;
        diff_set_mnemonic_prefix(&revs->diffopt, "1/", "2/");
        diffcore_std(&revs->diffopt);
        diff_flush(&revs->diffopt);
         * The return code for --no-index imitates diff(1):
         * 0 = no changes, 1 = changes, else error
         */
-       exit(diff_result_code(&revs->diffopt, 0));
+       return diff_result_code(&revs->diffopt, 0);
  }
diff --combined diff.c
index 6dfad79f1d67e9659eaaa207bf7a3e7c6a596a6b,11f26285c37a61da1d636713c4e8cdbe095c03d2..e30a645d9e01ecab1c12d8d14def7de5f6b8d2ed
--- 1/diff.c
--- 2/diff.c
+++ b/diff.c
@@@ -174,10 -174,6 +174,10 @@@ static int parse_submodule_params(struc
                options->submodule_format = DIFF_SUBMODULE_SHORT;
        else if (!strcmp(value, "diff"))
                options->submodule_format = DIFF_SUBMODULE_INLINE_DIFF;
 +      /*
 +       * Please update $__git_diff_submodule_formats in
 +       * git-completion.bash when you add new formats.
 +       */
        else
                return -1;
        return 0;
@@@ -204,10 -200,6 +204,10 @@@ long parse_algorithm_value(const char *
                return XDF_PATIENCE_DIFF;
        else if (!strcasecmp(value, "histogram"))
                return XDF_HISTOGRAM_DIFF;
 +      /*
 +       * Please update $__git_diff_algorithms in git-completion.bash
 +       * when you add new algorithms.
 +       */
        return -1;
  }
  
@@@ -308,9 -300,7 +308,9 @@@ static unsigned parse_color_moved_ws(co
                strbuf_addstr(&sb, i->string);
                strbuf_trim(&sb);
  
 -              if (!strcmp(sb.buf, "ignore-space-change"))
 +              if (!strcmp(sb.buf, "no"))
 +                      ret = 0;
 +              else if (!strcmp(sb.buf, "ignore-space-change"))
                        ret |= XDF_IGNORE_WHITESPACE_CHANGE;
                else if (!strcmp(sb.buf, "ignore-space-at-eol"))
                        ret |= XDF_IGNORE_WHITESPACE_AT_EOL;
  
        if ((ret & COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE) &&
            (ret & XDF_WHITESPACE_FLAGS)) {
 -              error(_("color-moved-ws: allow-indentation-change cannot be combined with other white space modes"));
 +              error(_("color-moved-ws: allow-indentation-change cannot be combined with other whitespace modes"));
                ret |= COLOR_MOVED_WS_ERROR;
        }
  
@@@ -499,7 -489,7 +499,7 @@@ static const char *external_diff(void
  
        if (done_preparing)
                return external_diff_cmd;
 -      external_diff_cmd = getenv("GIT_EXTERNAL_DIFF");
 +      external_diff_cmd = xstrdup_or_null(getenv("GIT_EXTERNAL_DIFF"));
        if (!external_diff_cmd)
                external_diff_cmd = external_diff_cmd_cfg;
        done_preparing = 1;
@@@ -760,8 -750,6 +760,8 @@@ struct emitted_diff_symbol 
        const char *line;
        int len;
        int flags;
 +      int indent_off;   /* Offset to first non-whitespace character */
 +      int indent_width; /* The visual width of the indentation */
        enum diff_symbol s;
  };
  #define EMITTED_DIFF_SYMBOL_INIT {NULL}
@@@ -792,85 -780,44 +792,85 @@@ struct moved_entry 
        struct moved_entry *next_line;
  };
  
 -/**
 - * The struct ws_delta holds white space differences between moved lines, i.e.
 - * between '+' and '-' lines that have been detected to be a move.
 - * The string contains the difference in leading white spaces, before the
 - * rest of the line is compared using the white space config for move
 - * coloring. The current_longer indicates if the first string in the
 - * comparision is longer than the second.
 - */
 -struct ws_delta {
 -      char *string;
 -      unsigned int current_longer : 1;
 -};
 -#define WS_DELTA_INIT { NULL, 0 }
 -
  struct moved_block {
        struct moved_entry *match;
 -      struct ws_delta wsd;
 +      int wsd; /* The whitespace delta of this block */
  };
  
  static void moved_block_clear(struct moved_block *b)
  {
 -      FREE_AND_NULL(b->wsd.string);
 -      b->match = NULL;
 +      memset(b, 0, sizeof(*b));
  }
  
 -static int compute_ws_delta(const struct emitted_diff_symbol *a,
 -                           const struct emitted_diff_symbol *b,
 -                           struct ws_delta *out)
 +#define INDENT_BLANKLINE INT_MIN
 +
 +static void fill_es_indent_data(struct emitted_diff_symbol *es)
  {
 -      const struct emitted_diff_symbol *longer =  a->len > b->len ? a : b;
 -      const struct emitted_diff_symbol *shorter = a->len > b->len ? b : a;
 -      int d = longer->len - shorter->len;
 +      unsigned int off = 0, i;
 +      int width = 0, tab_width = es->flags & WS_TAB_WIDTH_MASK;
 +      const char *s = es->line;
 +      const int len = es->len;
 +
 +      /* skip any \v \f \r at start of indentation */
 +      while (s[off] == '\f' || s[off] == '\v' ||
 +             (s[off] == '\r' && off < len - 1))
 +              off++;
 +
 +      /* calculate the visual width of indentation */
 +      while(1) {
 +              if (s[off] == ' ') {
 +                      width++;
 +                      off++;
 +              } else if (s[off] == '\t') {
 +                      width += tab_width - (width % tab_width);
 +                      while (s[++off] == '\t')
 +                              width += tab_width;
 +              } else {
 +                      break;
 +              }
 +      }
 +
 +      /* check if this line is blank */
 +      for (i = off; i < len; i++)
 +              if (!isspace(s[i]))
 +                  break;
 +
 +      if (i == len) {
 +              es->indent_width = INDENT_BLANKLINE;
 +              es->indent_off = len;
 +      } else {
 +              es->indent_off = off;
 +              es->indent_width = width;
 +      }
 +}
 +
 +static int compute_ws_delta(const struct emitted_diff_symbol *a,
 +                          const struct emitted_diff_symbol *b,
 +                          int *out)
 +{
 +      int a_len = a->len,
 +          b_len = b->len,
 +          a_off = a->indent_off,
 +          a_width = a->indent_width,
 +          b_off = b->indent_off,
 +          b_width = b->indent_width;
 +      int delta;
 +
 +      if (a_width == INDENT_BLANKLINE && b_width == INDENT_BLANKLINE) {
 +              *out = INDENT_BLANKLINE;
 +              return 1;
 +      }
  
 -      if (strncmp(longer->line + d, shorter->line, shorter->len))
 +      if (a->s == DIFF_SYMBOL_PLUS)
 +              delta = a_width - b_width;
 +      else
 +              delta = b_width - a_width;
 +
 +      if (a_len - a_off != b_len - b_off ||
 +          memcmp(a->line + a_off, b->line + b_off, a_len - a_off))
                return 0;
  
 -      out->string = xmemdupz(longer->line, d);
 -      out->current_longer = (a == longer);
 +      *out = delta;
  
        return 1;
  }
@@@ -882,53 -829,51 +882,53 @@@ static int cmp_in_block_with_wsd(const 
                                 int n)
  {
        struct emitted_diff_symbol *l = &o->emitted_symbols->buf[n];
 -      int al = cur->es->len, cl = l->len;
 +      int al = cur->es->len, bl = match->es->len, cl = l->len;
        const char *a = cur->es->line,
                   *b = match->es->line,
                   *c = l->line;
 -
 -      int wslen;
 +      int a_off = cur->es->indent_off,
 +          a_width = cur->es->indent_width,
 +          c_off = l->indent_off,
 +          c_width = l->indent_width;
 +      int delta;
  
        /*
 -       * We need to check if 'cur' is equal to 'match'.
 -       * As those are from the same (+/-) side, we do not need to adjust for
 -       * indent changes. However these were found using fuzzy matching
 -       * so we do have to check if they are equal.
 +       * We need to check if 'cur' is equal to 'match'.  As those
 +       * are from the same (+/-) side, we do not need to adjust for
 +       * indent changes. However these were found using fuzzy
 +       * matching so we do have to check if they are equal. Here we
 +       * just check the lengths. We delay calling memcmp() to check
 +       * the contents until later as if the length comparison for a
 +       * and c fails we can avoid the call all together.
         */
 -      if (strcmp(a, b))
 +      if (al != bl)
                return 1;
  
 -      if (!pmb->wsd.string)
 -              /*
 -               * The white space delta is not active? This can happen
 -               * when we exit early in this function.
 -               */
 -              return 1;
 +      /* If 'l' and 'cur' are both blank then they match. */
 +      if (a_width == INDENT_BLANKLINE && c_width == INDENT_BLANKLINE)
 +              return 0;
  
        /*
 -       * The indent changes of the block are known and stored in
 -       * pmb->wsd; however we need to check if the indent changes of the
 -       * current line are still the same as before.
 -       *
 -       * To do so we need to compare 'l' to 'cur', adjusting the
 -       * one of them for the white spaces, depending which was longer.
 +       * The indent changes of the block are known and stored in pmb->wsd;
 +       * however we need to check if the indent changes of the current line
 +       * match those of the current block and that the text of 'l' and 'cur'
 +       * after the indentation match.
         */
 +      if (cur->es->s == DIFF_SYMBOL_PLUS)
 +              delta = a_width - c_width;
 +      else
 +              delta = c_width - a_width;
  
 -      wslen = strlen(pmb->wsd.string);
 -      if (pmb->wsd.current_longer) {
 -              c += wslen;
 -              cl -= wslen;
 -      } else {
 -              a += wslen;
 -              al -= wslen;
 -      }
 -
 -      if (al != cl || memcmp(a, c, al))
 -              return 1;
 +      /*
 +       * If the previous lines of this block were all blank then set its
 +       * whitespace delta.
 +       */
 +      if (pmb->wsd == INDENT_BLANKLINE)
 +              pmb->wsd = delta;
  
 -      return 0;
 +      return !(delta == pmb->wsd && al - a_off == cl - c_off &&
 +               !memcmp(a, b, al) && !
 +               memcmp(a + a_off, c + c_off, al - a_off));
  }
  
  static int moved_entry_cmp(const void *hashmap_cmp_fn_data,
@@@ -994,9 -939,6 +994,9 @@@ static void add_lines_to_move_detection
                        continue;
                }
  
 +              if (o->color_moved_ws_handling &
 +                  COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE)
 +                      fill_es_indent_data(&o->emitted_symbols->buf[n]);
                key = prepare_entry(o, n);
                if (prev_line && prev_line->es->s == o->emitted_symbols->buf[n].s)
                        prev_line->next_line = key;
@@@ -1075,7 -1017,8 +1075,7 @@@ static int shrink_potential_moved_block
  
                if (lp < pmb_nr && rp > -1 && lp < rp) {
                        pmb[lp] = pmb[rp];
 -                      pmb[rp].match = NULL;
 -                      pmb[rp].wsd.string = NULL;
 +                      memset(&pmb[rp], 0, sizeof(pmb[rp]));
                        rp--;
                        lp++;
                }
   * The last block consists of the (n - block_length)'th line up to but not
   * including the nth line.
   *
 + * Returns 0 if the last block is empty or is unset by this function, non zero
 + * otherwise.
 + *
   * NEEDSWORK: This uses the same heuristic as blame_entry_score() in blame.c.
   * Think of a way to unify them.
   */
 -static void adjust_last_block(struct diff_options *o, int n, int block_length)
 +static int adjust_last_block(struct diff_options *o, int n, int block_length)
  {
        int i, alnum_count = 0;
        if (o->color_moved == COLOR_MOVED_PLAIN)
 -              return;
 +              return block_length;
        for (i = 1; i < block_length + 1; i++) {
                const char *c = o->emitted_symbols->buf[n - i].line;
                for (; *c; c++) {
                                continue;
                        alnum_count++;
                        if (alnum_count >= COLOR_MOVED_MIN_ALNUM_COUNT)
 -                              return;
 +                              return 1;
                }
        }
        for (i = 1; i < block_length + 1; i++)
                o->emitted_symbols->buf[n - i].flags &= ~DIFF_SYMBOL_MOVED_LINE;
 +      return 0;
  }
  
  /* Find blocks of moved code, delegate actual coloring decision to helper */
@@@ -1128,7 -1067,7 +1128,7 @@@ static void mark_color_as_moved(struct 
  {
        struct moved_block *pmb = NULL; /* potentially moved blocks */
        int pmb_nr = 0, pmb_alloc = 0;
 -      int n, flipped_block = 1, block_length = 0;
 +      int n, flipped_block = 0, block_length = 0;
  
  
        for (n = 0; n < o->emitted_symbols->nr; n++) {
                struct moved_entry *key;
                struct moved_entry *match = NULL;
                struct emitted_diff_symbol *l = &o->emitted_symbols->buf[n];
 +              enum diff_symbol last_symbol = 0;
  
                switch (l->s) {
                case DIFF_SYMBOL_PLUS:
                        free(key);
                        break;
                default:
 -                      flipped_block = 1;
 +                      flipped_block = 0;
                }
  
                if (!match) {
                                moved_block_clear(&pmb[i]);
                        pmb_nr = 0;
                        block_length = 0;
 +                      flipped_block = 0;
 +                      last_symbol = l->s;
                        continue;
                }
  
 -              l->flags |= DIFF_SYMBOL_MOVED_LINE;
 -
 -              if (o->color_moved == COLOR_MOVED_PLAIN)
 +              if (o->color_moved == COLOR_MOVED_PLAIN) {
 +                      last_symbol = l->s;
 +                      l->flags |= DIFF_SYMBOL_MOVED_LINE;
                        continue;
 +              }
  
                if (o->color_moved_ws_handling &
                    COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE)
                                                             &pmb[pmb_nr].wsd))
                                                pmb[pmb_nr++].match = match;
                                } else {
 -                                      pmb[pmb_nr].wsd.string = NULL;
 +                                      pmb[pmb_nr].wsd = 0;
                                        pmb[pmb_nr++].match = match;
                                }
                        }
  
 -                      flipped_block = (flipped_block + 1) % 2;
 +                      if (adjust_last_block(o, n, block_length) &&
 +                          pmb_nr && last_symbol != l->s)
 +                              flipped_block = (flipped_block + 1) % 2;
 +                      else
 +                              flipped_block = 0;
  
 -                      adjust_last_block(o, n, block_length);
                        block_length = 0;
                }
  
 -              block_length++;
 -
 -              if (flipped_block && o->color_moved != COLOR_MOVED_BLOCKS)
 -                      l->flags |= DIFF_SYMBOL_MOVED_LINE_ALT;
 +              if (pmb_nr) {
 +                      block_length++;
 +                      l->flags |= DIFF_SYMBOL_MOVED_LINE;
 +                      if (flipped_block && o->color_moved != COLOR_MOVED_BLOCKS)
 +                              l->flags |= DIFF_SYMBOL_MOVED_LINE_ALT;
 +              }
 +              last_symbol = l->s;
        }
        adjust_last_block(o, n, block_length);
  
@@@ -1559,7 -1488,7 +1559,7 @@@ static void emit_diff_symbol_from_struc
  static void emit_diff_symbol(struct diff_options *o, enum diff_symbol s,
                             const char *line, int len, unsigned flags)
  {
 -      struct emitted_diff_symbol e = {line, len, flags, s};
 +      struct emitted_diff_symbol e = {line, len, flags, 0, 0, s};
  
        if (o->emitted_symbols)
                append_emitted_diff_symbol(o, &e);
@@@ -1617,7 -1546,8 +1617,7 @@@ static int new_blank_line_at_eof(struc
        return ws_blank_line(line, len, ecbdata->ws_rule);
  }
  
 -static void emit_add_line(const char *reset,
 -                        struct emit_callback *ecbdata,
 +static void emit_add_line(struct emit_callback *ecbdata,
                          const char *line, int len)
  {
        unsigned flags = WSEH_NEW | ecbdata->ws_rule;
        emit_diff_symbol(ecbdata->opt, DIFF_SYMBOL_PLUS, line, len, flags);
  }
  
 -static void emit_del_line(const char *reset,
 -                        struct emit_callback *ecbdata,
 +static void emit_del_line(struct emit_callback *ecbdata,
                          const char *line, int len)
  {
        unsigned flags = WSEH_OLD | ecbdata->ws_rule;
        emit_diff_symbol(ecbdata->opt, DIFF_SYMBOL_MINUS, line, len, flags);
  }
  
 -static void emit_context_line(const char *reset,
 -                            struct emit_callback *ecbdata,
 +static void emit_context_line(struct emit_callback *ecbdata,
                              const char *line, int len)
  {
        unsigned flags = WSEH_CONTEXT | ecbdata->ws_rule;
@@@ -1743,6 -1675,7 +1743,6 @@@ static void emit_rewrite_lines(struct e
                               int prefix, const char *data, int size)
  {
        const char *endp = NULL;
 -      const char *reset = diff_get_color(ecb->color_diff, DIFF_RESET);
  
        while (0 < size) {
                int len;
                len = endp ? (endp - data + 1) : size;
                if (prefix != '+') {
                        ecb->lno_in_preimage++;
 -                      emit_del_line(reset, ecb, data, len);
 +                      emit_del_line(ecb, data, len);
                } else {
                        ecb->lno_in_postimage++;
 -                      emit_add_line(reset, ecb, data, len);
 +                      emit_add_line(ecb, data, len);
                }
                size -= len;
                data += len;
@@@ -2291,7 -2224,7 +2291,7 @@@ const char *diff_line_prefix(struct dif
        return msgbuf->buf;
  }
  
 -static unsigned long sane_truncate_line(struct emit_callback *ecb, char *line, unsigned long len)
 +static unsigned long sane_truncate_line(char *line, unsigned long len)
  {
        const char *cp;
        unsigned long allot;
@@@ -2325,6 -2258,7 +2325,6 @@@ static void find_lno(const char *line, 
  static void fn_out_consume(void *priv, char *line, unsigned long len)
  {
        struct emit_callback *ecbdata = priv;
 -      const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
        struct diff_options *o = ecbdata->opt;
  
        o->found_changes = 1;
        if (line[0] == '@') {
                if (ecbdata->diff_words)
                        diff_words_flush(ecbdata);
 -              len = sane_truncate_line(ecbdata, line, len);
 +              len = sane_truncate_line(line, len);
                find_lno(line, ecbdata);
                emit_hunk_header(ecbdata, line, len);
                return;
        switch (line[0]) {
        case '+':
                ecbdata->lno_in_postimage++;
 -              emit_add_line(reset, ecbdata, line + 1, len - 1);
 +              emit_add_line(ecbdata, line + 1, len - 1);
                break;
        case '-':
                ecbdata->lno_in_preimage++;
 -              emit_del_line(reset, ecbdata, line + 1, len - 1);
 +              emit_del_line(ecbdata, line + 1, len - 1);
                break;
        case ' ':
                ecbdata->lno_in_postimage++;
                ecbdata->lno_in_preimage++;
 -              emit_context_line(reset, ecbdata, line + 1, len - 1);
 +              emit_context_line(ecbdata, line + 1, len - 1);
                break;
        default:
                /* incomplete line at the end */
@@@ -3543,7 -3477,7 +3543,7 @@@ static void builtin_diff(const char *na
                o->found_changes = 1;
        } else {
                /* Crazy xdl interfaces.. */
 -              const char *diffopts = getenv("GIT_DIFF_OPTS");
 +              const char *diffopts;
                const char *v;
                xpparam_t xpp;
                xdemitconf_t xecfg;
                        xecfg.flags |= XDL_EMIT_FUNCCONTEXT;
                if (pe)
                        xdiff_set_find_func(&xecfg, pe->pattern, pe->cflags);
 +
 +              diffopts = getenv("GIT_DIFF_OPTS");
                if (!diffopts)
                        ;
                else if (skip_prefix(diffopts, "--unified=", &v))
                        xecfg.ctxlen = strtoul(v, NULL, 10);
                else if (skip_prefix(diffopts, "-u", &v))
                        xecfg.ctxlen = strtoul(v, NULL, 10);
 +
                if (o->word_diff)
                        init_diff_words_data(&ecbdata, o, one, two);
                if (xdi_diff_outf(&mf1, &mf2, NULL, fn_out_consume,
@@@ -4182,6 -4113,7 +4182,6 @@@ static void run_external_diff(const cha
                              struct diff_filespec *one,
                              struct diff_filespec *two,
                              const char *xfrm_msg,
 -                            int complete_rewrite,
                              struct diff_options *o)
  {
        struct argv_array argv = ARGV_ARRAY_INIT;
@@@ -4339,7 -4271,8 +4339,7 @@@ static void run_diff_cmd(const char *pg
        }
  
        if (pgm) {
 -              run_external_diff(pgm, name, other, one, two, xfrm_msg,
 -                                complete_rewrite, o);
 +              run_external_diff(pgm, name, other, one, two, xfrm_msg, o);
                return;
        }
        if (one && two)
@@@ -4640,66 -4573,6 +4640,6 @@@ void diff_setup_done(struct diff_option
        FREE_AND_NULL(options->parseopts);
  }
  
- static int opt_arg(const char *arg, int arg_short, const char *arg_long, int *val)
- {
-       char c, *eq;
-       int len;
-       if (*arg != '-')
-               return 0;
-       c = *++arg;
-       if (!c)
-               return 0;
-       if (c == arg_short) {
-               c = *++arg;
-               if (!c)
-                       return 1;
-               if (val && isdigit(c)) {
-                       char *end;
-                       int n = strtoul(arg, &end, 10);
-                       if (*end)
-                               return 0;
-                       *val = n;
-                       return 1;
-               }
-               return 0;
-       }
-       if (c != '-')
-               return 0;
-       arg++;
-       eq = strchrnul(arg, '=');
-       len = eq - arg;
-       if (!len || strncmp(arg, arg_long, len))
-               return 0;
-       if (*eq) {
-               int n;
-               char *end;
-               if (!isdigit(*++eq))
-                       return 0;
-               n = strtoul(eq, &end, 10);
-               if (*end)
-                       return 0;
-               *val = n;
-       }
-       return 1;
- }
- static inline int short_opt(char opt, const char **argv,
-                           const char **optarg)
- {
-       const char *arg = argv[0];
-       if (arg[0] != '-' || arg[1] != opt)
-               return 0;
-       if (arg[2] != '\0') {
-               *optarg = arg + 2;
-               return 1;
-       }
-       if (!argv[1])
-               die("Option '%c' requires a value", opt);
-       *optarg = argv[1];
-       return 2;
- }
  int parse_long_opt(const char *opt, const char **argv,
                   const char **optarg)
  {
@@@ -4819,10 -4692,19 +4759,19 @@@ static unsigned filter_bit_tst(char sta
        return opt->filter & filter_bit[(int) status];
  }
  
static int parse_diff_filter_opt(const char *optarg, struct diff_options *opt)
unsigned diff_filter_bit(char status)
  {
+       prepare_filter_bits();
+       return filter_bit[(int) status];
+ }
+ static int diff_opt_diff_filter(const struct option *option,
+                               const char *optarg, int unset)
+ {
+       struct diff_options *opt = option->value;
        int i, optch;
  
+       BUG_ON_OPT_NEG(unset);
        prepare_filter_bits();
  
        /*
  
                bit = (0 <= optch && optch <= 'Z') ? filter_bit[optch] : 0;
                if (!bit)
-                       return optarg[i];
+                       return error(_("unknown change class '%c' in --diff-filter=%s"),
+                                    optarg[i], optarg);
                if (negate)
                        opt->filter &= ~bit;
                else
@@@ -4868,25 -4751,29 +4818,29 @@@ static void enable_patch_output(int *fm
        *fmt |= DIFF_FORMAT_PATCH;
  }
  
- static int parse_ws_error_highlight_opt(struct diff_options *opt, const char *arg)
+ static int diff_opt_ws_error_highlight(const struct option *option,
+                                      const char *arg, int unset)
  {
+       struct diff_options *opt = option->value;
        int val = parse_ws_error_highlight(arg);
  
-       if (val < 0) {
-               error("unknown value after ws-error-highlight=%.*s",
-                     -1 - val, arg);
-               return 0;
-       }
+       BUG_ON_OPT_NEG(unset);
+       if (val < 0)
+               return error(_("unknown value after ws-error-highlight=%.*s"),
+                            -1 - val, arg);
        opt->ws_error_highlight = val;
-       return 1;
+       return 0;
  }
  
- static int parse_objfind_opt(struct diff_options *opt, const char *arg)
+ static int diff_opt_find_object(const struct option *option,
+                               const char *arg, int unset)
  {
+       struct diff_options *opt = option->value;
        struct object_id oid;
  
+       BUG_ON_OPT_NEG(unset);
        if (get_oid(arg, &oid))
-               return error("unable to resolve '%s'", arg);
+               return error(_("unable to resolve '%s'"), arg);
  
        if (!opt->objfind)
                opt->objfind = xcalloc(1, sizeof(*opt->objfind));
        opt->flags.recursive = 1;
        opt->flags.tree_in_recursive = 1;
        oidset_insert(opt->objfind, &oid);
-       return 1;
+       return 0;
  }
  
  static int diff_opt_anchored(const struct option *opt,
@@@ -4960,6 -4847,45 +4914,45 @@@ static int diff_opt_char(const struct o
        return 0;
  }
  
+ static int diff_opt_color_moved(const struct option *opt,
+                               const char *arg, int unset)
+ {
+       struct diff_options *options = opt->value;
+       if (unset) {
+               options->color_moved = COLOR_MOVED_NO;
+       } else if (!arg) {
+               if (diff_color_moved_default)
+                       options->color_moved = diff_color_moved_default;
+               if (options->color_moved == COLOR_MOVED_NO)
+                       options->color_moved = COLOR_MOVED_DEFAULT;
+       } else {
+               int cm = parse_color_moved(arg);
+               if (cm < 0)
+                       return error(_("bad --color-moved argument: %s"), arg);
+               options->color_moved = cm;
+       }
+       return 0;
+ }
+ static int diff_opt_color_moved_ws(const struct option *opt,
+                                  const char *arg, int unset)
+ {
+       struct diff_options *options = opt->value;
+       unsigned cm;
+       if (unset) {
+               options->color_moved_ws_handling = 0;
+               return 0;
+       }
+       cm = parse_color_moved_ws(arg);
+       if (cm & COLOR_MOVED_WS_ERROR)
+               return error(_("invalid mode '%s' in --color-moved-ws"), arg);
+       options->color_moved_ws_handling = cm;
+       return 0;
+ }
  static int diff_opt_color_words(const struct option *opt,
                                const char *arg, int unset)
  {
@@@ -5085,6 -5011,30 +5078,30 @@@ static int diff_opt_ignore_submodules(c
        return 0;
  }
  
+ static int diff_opt_line_prefix(const struct option *opt,
+                               const char *optarg, int unset)
+ {
+       struct diff_options *options = opt->value;
+       BUG_ON_OPT_NEG(unset);
+       options->line_prefix = optarg;
+       options->line_prefix_length = strlen(options->line_prefix);
+       graph_setup_line_prefix(options);
+       return 0;
+ }
+ static int diff_opt_no_prefix(const struct option *opt,
+                             const char *optarg, int unset)
+ {
+       struct diff_options *options = opt->value;
+       BUG_ON_OPT_NEG(unset);
+       BUG_ON_OPT_ARG(optarg);
+       options->a_prefix = "";
+       options->b_prefix = "";
+       return 0;
+ }
  static enum parse_opt_result diff_opt_output(struct parse_opt_ctx_t *ctx,
                                             const struct option *opt,
                                             const char *arg, int unset)
@@@ -5122,6 -5072,28 +5139,28 @@@ static int diff_opt_patience(const stru
        return 0;
  }
  
+ static int diff_opt_pickaxe_regex(const struct option *opt,
+                                 const char *arg, int unset)
+ {
+       struct diff_options *options = opt->value;
+       BUG_ON_OPT_NEG(unset);
+       options->pickaxe = arg;
+       options->pickaxe_opts |= DIFF_PICKAXE_KIND_G;
+       return 0;
+ }
+ static int diff_opt_pickaxe_string(const struct option *opt,
+                                  const char *arg, int unset)
+ {
+       struct diff_options *options = opt->value;
+       BUG_ON_OPT_NEG(unset);
+       options->pickaxe = arg;
+       options->pickaxe_opts |= DIFF_PICKAXE_KIND_S;
+       return 0;
+ }
  static int diff_opt_relative(const struct option *opt,
                             const char *arg, int unset)
  {
@@@ -5301,6 -5273,28 +5340,28 @@@ static void prep_parse_options(struct d
                         N_("show full pre- and post-image object names on the \"index\" lines")),
                OPT_COLOR_FLAG(0, "color", &options->use_color,
                               N_("show colored diff")),
+               OPT_CALLBACK_F(0, "ws-error-highlight", options, N_("<kind>"),
+                              N_("highlight whitespace errors in the 'context', 'old' or 'new' lines in the diff"),
+                              PARSE_OPT_NONEG, diff_opt_ws_error_highlight),
+               OPT_SET_INT('z', NULL, &options->line_termination,
+                           N_("do not munge pathnames and use NULs as output field terminators in --raw or --numstat"),
+                           0),
+               OPT__ABBREV(&options->abbrev),
+               OPT_STRING_F(0, "src-prefix", &options->a_prefix, N_("<prefix>"),
+                            N_("show the given source prefix instead of \"a/\""),
+                            PARSE_OPT_NONEG),
+               OPT_STRING_F(0, "dst-prefix", &options->b_prefix, N_("<prefix>"),
+                            N_("show the given source prefix instead of \"b/\""),
+                            PARSE_OPT_NONEG),
+               OPT_CALLBACK_F(0, "line-prefix", options, N_("<prefix>"),
+                              N_("prepend an additional prefix to every line of output"),
+                              PARSE_OPT_NONEG, diff_opt_line_prefix),
+               OPT_CALLBACK_F(0, "no-prefix", options, NULL,
+                              N_("do not show any source or destination prefix"),
+                              PARSE_OPT_NONEG | PARSE_OPT_NOARG, diff_opt_no_prefix),
+               OPT_INTEGER_F(0, "inter-hunk-context", &options->interhunkcontext,
+                             N_("show context between diff hunks up to the specified number of lines"),
+                             PARSE_OPT_NONEG),
                OPT_CALLBACK_F(0, "output-indicator-new",
                               &options->output_indicators[OUTPUT_INDICATOR_NEW],
                               N_("<char>"),
                OPT_CALLBACK_F(0, "follow", options, NULL,
                               N_("continue listing the history of a file beyond renames"),
                               PARSE_OPT_NOARG, diff_opt_follow),
+               OPT_INTEGER('l', NULL, &options->rename_limit,
+                           N_("prevent rename/copy detection if the number of rename/copy targets exceeds given limit")),
  
                OPT_GROUP(N_("Diff algorithm options")),
                OPT_BIT(0, "minimal", &options->xdl_opts,
                OPT_CALLBACK_F(0, "color-words", options, N_("<regex>"),
                               N_("equivalent to --word-diff=color --word-diff-regex=<regex>"),
                               PARSE_OPT_NONEG | PARSE_OPT_OPTARG, diff_opt_color_words),
+               OPT_CALLBACK_F(0, "color-moved", options, N_("<mode>"),
+                              N_("move lines of code are colored differently"),
+                              PARSE_OPT_OPTARG, diff_opt_color_moved),
+               OPT_CALLBACK_F(0, "color-moved-ws", options, N_("<mode>"),
+                              N_("how white spaces are ignored in --color-moved"),
+                              0, diff_opt_color_moved_ws),
  
                OPT_GROUP(N_("Diff other options")),
                OPT_CALLBACK_F(0, "relative", options, N_("<prefix>"),
                               N_("specify how differences in submodules are shown"),
                               PARSE_OPT_NONEG | PARSE_OPT_OPTARG,
                               diff_opt_submodule),
+               OPT_SET_INT_F(0, "ita-invisible-in-index", &options->ita_invisible_in_index,
+                             N_("hide 'git add -N' entries from the index"),
+                             1, PARSE_OPT_NONEG),
+               OPT_SET_INT_F(0, "ita-visible-in-index", &options->ita_invisible_in_index,
+                             N_("treat 'git add -N' entries as real in the index"),
+                             0, PARSE_OPT_NONEG),
+               OPT_CALLBACK_F('S', NULL, options, N_("<string>"),
+                              N_("look for differences that change the number of occurrences of the specified string"),
+                              0, diff_opt_pickaxe_string),
+               OPT_CALLBACK_F('G', NULL, options, N_("<regex>"),
+                              N_("look for differences that change the number of occurrences of the specified regex"),
+                              0, diff_opt_pickaxe_regex),
+               OPT_BIT_F(0, "pickaxe-all", &options->pickaxe_opts,
+                         N_("show all changes in the changeset with -S or -G"),
+                         DIFF_PICKAXE_ALL, PARSE_OPT_NONEG),
+               OPT_BIT_F(0, "pickaxe-regex", &options->pickaxe_opts,
+                         N_("treat <string> in -S as extended POSIX regular expression"),
+                         DIFF_PICKAXE_REGEX, PARSE_OPT_NONEG),
+               OPT_FILENAME('O', NULL, &options->orderfile,
+                            N_("control the order in which files appear in the output")),
+               OPT_CALLBACK_F(0, "find-object", options, N_("<object-id>"),
+                              N_("look for differences that change the number of occurrences of the specified object"),
+                              PARSE_OPT_NONEG, diff_opt_find_object),
+               OPT_CALLBACK_F(0, "diff-filter", options, N_("[(A|C|D|M|R|T|U|X|B)...[*]]"),
+                              N_("select files by diff type"),
+                              PARSE_OPT_NONEG, diff_opt_diff_filter),
                { OPTION_CALLBACK, 0, "output", options, N_("<file>"),
                  N_("Output to a specific file"),
                  PARSE_OPT_NONEG, NULL, 0, diff_opt_output },
  int diff_opt_parse(struct diff_options *options,
                   const char **av, int ac, const char *prefix)
  {
-       const char *arg = av[0];
-       const char *optarg;
-       int argcount;
        if (!prefix)
                prefix = "";
  
                           PARSE_OPT_ONE_SHOT |
                           PARSE_OPT_STOP_AT_NON_OPTION);
  
-       if (ac)
-               return ac;
-       /* flags options */
-       if (!strcmp(arg, "--color-moved")) {
-               if (diff_color_moved_default)
-                       options->color_moved = diff_color_moved_default;
-               if (options->color_moved == COLOR_MOVED_NO)
-                       options->color_moved = COLOR_MOVED_DEFAULT;
-       } else if (!strcmp(arg, "--no-color-moved"))
-               options->color_moved = COLOR_MOVED_NO;
-       else if (skip_prefix(arg, "--color-moved=", &arg)) {
-               int cm = parse_color_moved(arg);
-               if (cm < 0)
-                       return error("bad --color-moved argument: %s", arg);
-               options->color_moved = cm;
-       } else if (!strcmp(arg, "--no-color-moved-ws")) {
-               options->color_moved_ws_handling = 0;
-       } else if (skip_prefix(arg, "--color-moved-ws=", &arg)) {
-               unsigned cm = parse_color_moved_ws(arg);
-               if (cm & COLOR_MOVED_WS_ERROR)
-                       return -1;
-               options->color_moved_ws_handling = cm;
-       } else if (skip_prefix(arg, "--ws-error-highlight=", &arg))
-               return parse_ws_error_highlight_opt(options, arg);
-       else if (!strcmp(arg, "--ita-invisible-in-index"))
-               options->ita_invisible_in_index = 1;
-       else if (!strcmp(arg, "--ita-visible-in-index"))
-               options->ita_invisible_in_index = 0;
-       /* misc options */
-       else if (!strcmp(arg, "-z"))
-               options->line_termination = 0;
-       else if ((argcount = short_opt('l', av, &optarg))) {
-               options->rename_limit = strtoul(optarg, NULL, 10);
-               return argcount;
-       }
-       else if ((argcount = short_opt('S', av, &optarg))) {
-               options->pickaxe = optarg;
-               options->pickaxe_opts |= DIFF_PICKAXE_KIND_S;
-               return argcount;
-       } else if ((argcount = short_opt('G', av, &optarg))) {
-               options->pickaxe = optarg;
-               options->pickaxe_opts |= DIFF_PICKAXE_KIND_G;
-               return argcount;
-       }
-       else if (!strcmp(arg, "--pickaxe-all"))
-               options->pickaxe_opts |= DIFF_PICKAXE_ALL;
-       else if (!strcmp(arg, "--pickaxe-regex"))
-               options->pickaxe_opts |= DIFF_PICKAXE_REGEX;
-       else if ((argcount = short_opt('O', av, &optarg))) {
-               options->orderfile = prefix_filename(prefix, optarg);
-               return argcount;
-       } else if (skip_prefix(arg, "--find-object=", &arg))
-               return parse_objfind_opt(options, arg);
-       else if ((argcount = parse_long_opt("diff-filter", av, &optarg))) {
-               int offending = parse_diff_filter_opt(optarg, options);
-               if (offending)
-                       die("unknown change class '%c' in --diff-filter=%s",
-                           offending, optarg);
-               return argcount;
-       }
-       else if (!strcmp(arg, "--no-abbrev"))
-               options->abbrev = 0;
-       else if (!strcmp(arg, "--abbrev"))
-               options->abbrev = DEFAULT_ABBREV;
-       else if (skip_prefix(arg, "--abbrev=", &arg)) {
-               options->abbrev = strtoul(arg, NULL, 10);
-               if (options->abbrev < MINIMUM_ABBREV)
-                       options->abbrev = MINIMUM_ABBREV;
-               else if (the_hash_algo->hexsz < options->abbrev)
-                       options->abbrev = the_hash_algo->hexsz;
-       }
-       else if ((argcount = parse_long_opt("src-prefix", av, &optarg))) {
-               options->a_prefix = optarg;
-               return argcount;
-       }
-       else if ((argcount = parse_long_opt("line-prefix", av, &optarg))) {
-               options->line_prefix = optarg;
-               options->line_prefix_length = strlen(options->line_prefix);
-               graph_setup_line_prefix(options);
-               return argcount;
-       }
-       else if ((argcount = parse_long_opt("dst-prefix", av, &optarg))) {
-               options->b_prefix = optarg;
-               return argcount;
-       }
-       else if (!strcmp(arg, "--no-prefix"))
-               options->a_prefix = options->b_prefix = "";
-       else if (opt_arg(arg, '\0', "inter-hunk-context",
-                        &options->interhunkcontext))
-               ;
-       else
-               return 0;
-       return 1;
+       return ac;
  }
  
  int parse_rename_score(const char **cp_p)
@@@ -6212,10 -6142,8 +6209,10 @@@ static void diff_flush_patch_all_file_p
  
                for (i = 0; i < esm.nr; i++)
                        free((void *)esm.buf[i].line);
 +              esm.nr = 0;
 +
 +              o->emitted_symbols = NULL;
        }
 -      esm.nr = 0;
  }
  
  void diff_flush(struct diff_options *options)
@@@ -6474,7 -6402,7 +6471,7 @@@ static int diffnamecmp(const void *a_, 
        return strcmp(name_a, name_b);
  }
  
 -void diffcore_fix_diff_index(struct diff_options *options)
 +void diffcore_fix_diff_index(void)
  {
        struct diff_queue_struct *q = &diff_queued_diff;
        QSORT(q->queue, q->nr, diffnamecmp);
diff --combined diff.h
index c9db9825bb782fda45f463c3f51600fb3756b7c1,f88482705ca84424854d7d46af4efce96b6784aa..b20cbcc0914250de4921310d16d58ada4acb7984
--- 1/diff.h
--- 2/diff.h
+++ b/diff.h
@@@ -233,6 -233,8 +233,8 @@@ struct diff_options 
        struct option *parseopts;
  };
  
+ unsigned diff_filter_bit(char status);
  void diff_emit_submodule_del(struct diff_options *o, const char *line);
  void diff_emit_submodule_add(struct diff_options *o, const char *line);
  void diff_emit_submodule_untracked(struct diff_options *o, const char *path);
@@@ -296,7 -298,6 +298,7 @@@ struct combine_diff_path 
                char status;
                unsigned int mode;
                struct object_id oid;
 +              struct strbuf path;
        } parent[FLEX_ARRAY];
  };
  #define combine_diff_path_size(n, l) \
@@@ -370,7 -371,7 +372,7 @@@ int git_config_rename(const char *var, 
  #define DIFF_PICKAXE_IGNORE_CASE      32
  
  void diffcore_std(struct diff_options *);
 -void diffcore_fix_diff_index(struct diff_options *);
 +void diffcore_fix_diff_index(void);
  
  #define COMMON_DIFF_OPTIONS_HELP \
  "\ncommon diff options:\n" \
@@@ -438,7 -439,8 +440,8 @@@ int diff_flush_patch_id(struct diff_opt
  
  int diff_result_code(struct diff_options *, int);
  
- void diff_no_index(struct rev_info *, int, const char **);
 -int diff_no_index(struct repository *, struct rev_info *,
++int diff_no_index(struct rev_info *,
+                 int implicit_no_index, int, const char **);
  
  int index_differs_from(struct repository *r, const char *def,
                       const struct diff_flags *flags,
diff --combined parse-options.h
index 74cce4e7fce74237292e0b34bec2b02e0e945ca7,cca64d04cb1f5e66248f49988ffaee6f8c894db6..0f7378706610bc9cf394d012e5cd02ef272b5ef4
@@@ -136,6 -136,8 +136,8 @@@ struct option 
  #define OPT_BOOL_F(s, l, v, h, f)   OPT_SET_INT_F(s, l, v, h, 1, f)
  #define OPT_CALLBACK_F(s, l, v, a, h, f, cb)                  \
        { OPTION_CALLBACK, (s), (l), (v), (a), (h), (f), (cb) }
+ #define OPT_STRING_F(s, l, v, a, h, f)   { OPTION_STRING,  (s), (l), (v), (a), (h), (f) }
+ #define OPT_INTEGER_F(s, l, v, h, f)     { OPTION_INTEGER, (s), (l), (v), N_("n"), (h), (f) }
  
  #define OPT_END()                   { OPTION_END }
  #define OPT_ARGUMENT(l, h)          { OPTION_ARGUMENT, 0, (l), NULL, NULL, \
                                      (h), PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, NULL, 1}
  #define OPT_CMDMODE(s, l, v, h, i)  { OPTION_CMDMODE, (s), (l), (v), NULL, \
                                      (h), PARSE_OPT_NOARG|PARSE_OPT_NONEG, NULL, (i) }
- #define OPT_INTEGER(s, l, v, h)     { OPTION_INTEGER, (s), (l), (v), N_("n"), (h) }
+ #define OPT_INTEGER(s, l, v, h)     OPT_INTEGER_F(s, l, v, h, 0)
  #define OPT_MAGNITUDE(s, l, v, h)   { OPTION_MAGNITUDE, (s), (l), (v), \
                                      N_("n"), (h), PARSE_OPT_NONEG }
- #define OPT_STRING(s, l, v, a, h)   { OPTION_STRING,  (s), (l), (v), (a), (h) }
+ #define OPT_STRING(s, l, v, a, h)   OPT_STRING_F(s, l, v, a, h, 0)
  #define OPT_STRING_LIST(s, l, v, a, h) \
                                    { OPTION_CALLBACK, (s), (l), (v), (a), \
                                      (h), 0, &parse_opt_string_list }
@@@ -222,17 -224,6 +224,17 @@@ const char *optname(const struct optio
                BUG("option callback does not expect an argument"); \
  } while (0)
  
 +/*
 + * Similar to the assertions above, but checks that "arg" is always non-NULL.
 + * This assertion also implies BUG_ON_OPT_NEG(), letting you declare both
 + * assertions in a single line.
 + */
 +#define BUG_ON_OPT_NEG_NOARG(unset, arg) do { \
 +      BUG_ON_OPT_NEG(unset); \
 +      if(!(arg)) \
 +              BUG("option callback expects an argument"); \
 +} while(0)
 +
  /*----- incremental advanced APIs -----*/
  
  enum parse_opt_result {
diff --combined t/t4053-diff-no-index.sh
index 4331b3118a07f900305fa783914091f73653bb45,fb25cdb789b17db779f56f7ad0edefa8da615514..0168946b6394092bbedc4da6d57ef9ba8e205927
@@@ -50,8 -50,7 +50,7 @@@ test_expect_success 'git diff --no-inde
                export GIT_CEILING_DIRECTORIES &&
                cd non/git &&
                test_must_fail git diff --no-index a 2>actual.err &&
-               echo "usage: git diff --no-index <path> <path>" >expect.err &&
-               test_cmp expect.err actual.err
+               test_i18ngrep "usage: git diff --no-index" actual.err
        )
  '
  
@@@ -137,12 -136,4 +136,12 @@@ test_expect_success 'diff --no-index fr
        test_cmp expect actual
  '
  
 +test_expect_success 'diff --no-index allows external diff' '
 +      test_expect_code 1 \
 +              env GIT_EXTERNAL_DIFF="echo external ;:" \
 +              git diff --no-index non/git/a non/git/b >actual &&
 +      echo external >expect &&
 +      test_cmp expect actual
 +'
 +
  test_done