Merge branch 'nd/diff-parseopt-2'
Second batch to teach the diff machinery to use the parse-options API. * nd/diff-parseopt-2: (21 commits) diff-parseopt: convert --ignore-some-changes diff-parseopt: convert --[no-]minimal diff-parseopt: convert --relative diff-parseopt: convert --no-renames|--[no--rename-empty diff-parseopt: convert --find-copies-harder diff-parseopt: convert -C|--find-copies diff-parseopt: convert -D|--irreversible-delete diff-parseopt: convert -M|--find-renames diff-parseopt: convert -B|--break-rewrites diff-parseopt: convert --output-* diff-parseopt: convert --[no-]compact-summary diff-parseopt: convert --stat* diff-parseopt: convert -s|--no-patch diff-parseopt: convert --name-status diff-parseopt: convert --name-only diff-parseopt: convert --patch-with-stat diff-parseopt: convert --summary diff-parseopt: convert --check diff-parseopt: convert --dirstat and friends diff-parseopt: convert --numstat and --shortstat ...
This commit is contained in:
Junio C Hamano
commit
4ab0f13857
@ -41,6 +41,16 @@ ifndef::git-format-patch[]
|
||||
Implies `-p`.
|
||||
endif::git-format-patch[]
|
||||
|
||||
--output=<file>::
|
||||
Output to a specific file instead of stdout.
|
||||
|
||||
--output-indicator-new=<char>::
|
||||
--output-indicator-old=<char>::
|
||||
--output-indicator-context=<char>::
|
||||
Specify the character used to indicate new, old or context
|
||||
lines in the generated patch. Normally they are '+', '-' and
|
||||
' ' respectively.
|
||||
|
||||
ifndef::git-format-patch[]
|
||||
--raw::
|
||||
ifndef::git-log[]
|
||||
@ -148,6 +158,7 @@ These parameters can also be set individually with `--stat-width=<width>`,
|
||||
number of modified files, as well as number of added and deleted
|
||||
lines.
|
||||
|
||||
-X[<param1,param2,...>]::
|
||||
--dirstat[=<param1,param2,...>]::
|
||||
Output the distribution of relative amount of changes for each
|
||||
sub-directory. The behavior of `--dirstat` can be customized by
|
||||
@ -192,6 +203,12 @@ directories with less than 10% of the total amount of changed files,
|
||||
and accumulating child directory counts in the parent directories:
|
||||
`--dirstat=files,10,cumulative`.
|
||||
|
||||
--cumulative::
|
||||
Synonym for --dirstat=cumulative
|
||||
|
||||
--dirstat-by-file[=<param1,param2>...]::
|
||||
Synonym for --dirstat=files,param1,param2...
|
||||
|
||||
--summary::
|
||||
Output a condensed summary of extended header information
|
||||
such as creations, renames and mode changes.
|
||||
@ -386,6 +403,9 @@ endif::git-format-patch[]
|
||||
Turn off rename detection, even when the configuration
|
||||
file gives the default to do so.
|
||||
|
||||
--[no-]rename-empty::
|
||||
Whether to use empty blobs as rename source.
|
||||
|
||||
ifndef::git-format-patch[]
|
||||
--check::
|
||||
Warn if changes introduce conflict markers or whitespace errors.
|
||||
|
||||
510
diff.c
510
diff.c
@ -104,11 +104,6 @@ static const char *color_diff_slots[] = {
|
||||
[DIFF_FILE_NEW_BOLD] = "newBold",
|
||||
};
|
||||
|
||||
static NORETURN void die_want_option(const char *option_name)
|
||||
{
|
||||
die(_("option '%s' requires a value"), option_name);
|
||||
}
|
||||
|
||||
define_list_config_array_extra(color_diff_slots, {"plain"});
|
||||
|
||||
static int parse_diff_color_slot(const char *var)
|
||||
@ -4689,8 +4684,6 @@ static int opt_arg(const char *arg, int arg_short, const char *arg_long, int *va
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int diff_scoreopt_parse(const char *opt);
|
||||
|
||||
static inline int short_opt(char opt, const char **argv,
|
||||
const char **optarg)
|
||||
{
|
||||
@ -4728,77 +4721,56 @@ int parse_long_opt(const char *opt, const char **argv,
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int stat_opt(struct diff_options *options, const char **av)
|
||||
static int diff_opt_stat(const struct option *opt, const char *value, int unset)
|
||||
{
|
||||
const char *arg = av[0];
|
||||
char *end;
|
||||
struct diff_options *options = opt->value;
|
||||
int width = options->stat_width;
|
||||
int name_width = options->stat_name_width;
|
||||
int graph_width = options->stat_graph_width;
|
||||
int count = options->stat_count;
|
||||
int argcount = 1;
|
||||
char *end;
|
||||
|
||||
if (!skip_prefix(arg, "--stat", &arg))
|
||||
BUG("stat option does not begin with --stat: %s", arg);
|
||||
end = (char *)arg;
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
|
||||
switch (*arg) {
|
||||
case '-':
|
||||
if (skip_prefix(arg, "-width", &arg)) {
|
||||
if (*arg == '=')
|
||||
width = strtoul(arg + 1, &end, 10);
|
||||
else if (!*arg && !av[1])
|
||||
die_want_option("--stat-width");
|
||||
else if (!*arg) {
|
||||
width = strtoul(av[1], &end, 10);
|
||||
argcount = 2;
|
||||
}
|
||||
} else if (skip_prefix(arg, "-name-width", &arg)) {
|
||||
if (*arg == '=')
|
||||
name_width = strtoul(arg + 1, &end, 10);
|
||||
else if (!*arg && !av[1])
|
||||
die_want_option("--stat-name-width");
|
||||
else if (!*arg) {
|
||||
name_width = strtoul(av[1], &end, 10);
|
||||
argcount = 2;
|
||||
}
|
||||
} else if (skip_prefix(arg, "-graph-width", &arg)) {
|
||||
if (*arg == '=')
|
||||
graph_width = strtoul(arg + 1, &end, 10);
|
||||
else if (!*arg && !av[1])
|
||||
die_want_option("--stat-graph-width");
|
||||
else if (!*arg) {
|
||||
graph_width = strtoul(av[1], &end, 10);
|
||||
argcount = 2;
|
||||
}
|
||||
} else if (skip_prefix(arg, "-count", &arg)) {
|
||||
if (*arg == '=')
|
||||
count = strtoul(arg + 1, &end, 10);
|
||||
else if (!*arg && !av[1])
|
||||
die_want_option("--stat-count");
|
||||
else if (!*arg) {
|
||||
count = strtoul(av[1], &end, 10);
|
||||
argcount = 2;
|
||||
}
|
||||
if (!strcmp(opt->long_name, "stat")) {
|
||||
if (value) {
|
||||
width = strtoul(value, &end, 10);
|
||||
if (*end == ',')
|
||||
name_width = strtoul(end+1, &end, 10);
|
||||
if (*end == ',')
|
||||
count = strtoul(end+1, &end, 10);
|
||||
if (*end)
|
||||
return error(_("invalid --stat value: %s"), value);
|
||||
}
|
||||
break;
|
||||
case '=':
|
||||
width = strtoul(arg+1, &end, 10);
|
||||
if (*end == ',')
|
||||
name_width = strtoul(end+1, &end, 10);
|
||||
if (*end == ',')
|
||||
count = strtoul(end+1, &end, 10);
|
||||
}
|
||||
} else if (!strcmp(opt->long_name, "stat-width")) {
|
||||
width = strtoul(value, &end, 10);
|
||||
if (*end)
|
||||
return error(_("%s expects a numerical value"),
|
||||
opt->long_name);
|
||||
} else if (!strcmp(opt->long_name, "stat-name-width")) {
|
||||
name_width = strtoul(value, &end, 10);
|
||||
if (*end)
|
||||
return error(_("%s expects a numerical value"),
|
||||
opt->long_name);
|
||||
} else if (!strcmp(opt->long_name, "stat-graph-width")) {
|
||||
graph_width = strtoul(value, &end, 10);
|
||||
if (*end)
|
||||
return error(_("%s expects a numerical value"),
|
||||
opt->long_name);
|
||||
} else if (!strcmp(opt->long_name, "stat-count")) {
|
||||
count = strtoul(value, &end, 10);
|
||||
if (*end)
|
||||
return error(_("%s expects a numerical value"),
|
||||
opt->long_name);
|
||||
} else
|
||||
BUG("%s should not get here", opt->long_name);
|
||||
|
||||
/* Important! This checks all the error cases! */
|
||||
if (*end)
|
||||
return 0;
|
||||
options->output_format |= DIFF_FORMAT_DIFFSTAT;
|
||||
options->stat_name_width = name_width;
|
||||
options->stat_graph_width = graph_width;
|
||||
options->stat_width = width;
|
||||
options->stat_count = count;
|
||||
return argcount;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_dirstat_opt(struct diff_options *options, const char *params)
|
||||
@ -4934,6 +4906,139 @@ static int parse_objfind_opt(struct diff_options *opt, const char *arg)
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int diff_opt_break_rewrites(const struct option *opt,
|
||||
const char *arg, int unset)
|
||||
{
|
||||
int *break_opt = opt->value;
|
||||
int opt1, opt2;
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
if (!arg)
|
||||
arg = "";
|
||||
opt1 = parse_rename_score(&arg);
|
||||
if (*arg == 0)
|
||||
opt2 = 0;
|
||||
else if (*arg != '/')
|
||||
return error(_("%s expects <n>/<m> form"), opt->long_name);
|
||||
else {
|
||||
arg++;
|
||||
opt2 = parse_rename_score(&arg);
|
||||
}
|
||||
if (*arg != 0)
|
||||
return error(_("%s expects <n>/<m> form"), opt->long_name);
|
||||
*break_opt = opt1 | (opt2 << 16);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int diff_opt_char(const struct option *opt,
|
||||
const char *arg, int unset)
|
||||
{
|
||||
char *value = opt->value;
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
if (arg[1])
|
||||
return error(_("%s expects a character, got '%s'"),
|
||||
opt->long_name, arg);
|
||||
*value = arg[0];
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int diff_opt_compact_summary(const struct option *opt,
|
||||
const char *arg, int unset)
|
||||
{
|
||||
struct diff_options *options = opt->value;
|
||||
|
||||
BUG_ON_OPT_ARG(arg);
|
||||
if (unset) {
|
||||
options->flags.stat_with_summary = 0;
|
||||
} else {
|
||||
options->flags.stat_with_summary = 1;
|
||||
options->output_format |= DIFF_FORMAT_DIFFSTAT;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int diff_opt_dirstat(const struct option *opt,
|
||||
const char *arg, int unset)
|
||||
{
|
||||
struct diff_options *options = opt->value;
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
if (!strcmp(opt->long_name, "cumulative")) {
|
||||
if (arg)
|
||||
BUG("how come --cumulative take a value?");
|
||||
arg = "cumulative";
|
||||
} else if (!strcmp(opt->long_name, "dirstat-by-file"))
|
||||
parse_dirstat_opt(options, "files");
|
||||
parse_dirstat_opt(options, arg ? arg : "");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int diff_opt_find_copies(const struct option *opt,
|
||||
const char *arg, int unset)
|
||||
{
|
||||
struct diff_options *options = opt->value;
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
if (!arg)
|
||||
arg = "";
|
||||
options->rename_score = parse_rename_score(&arg);
|
||||
if (*arg != 0)
|
||||
return error(_("invalid argument to %s"), opt->long_name);
|
||||
|
||||
if (options->detect_rename == DIFF_DETECT_COPY)
|
||||
options->flags.find_copies_harder = 1;
|
||||
else
|
||||
options->detect_rename = DIFF_DETECT_COPY;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int diff_opt_find_renames(const struct option *opt,
|
||||
const char *arg, int unset)
|
||||
{
|
||||
struct diff_options *options = opt->value;
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
if (!arg)
|
||||
arg = "";
|
||||
options->rename_score = parse_rename_score(&arg);
|
||||
if (*arg != 0)
|
||||
return error(_("invalid argument to %s"), opt->long_name);
|
||||
|
||||
options->detect_rename = DIFF_DETECT_RENAME;
|
||||
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)
|
||||
{
|
||||
struct diff_options *options = opt->value;
|
||||
char *path;
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
path = prefix_filename(ctx->prefix, arg);
|
||||
options->file = xfopen(path, "w");
|
||||
options->close_file = 1;
|
||||
if (options->use_color != GIT_COLOR_ALWAYS)
|
||||
options->use_color = GIT_COLOR_NEVER;
|
||||
free(path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int diff_opt_relative(const struct option *opt,
|
||||
const char *arg, int unset)
|
||||
{
|
||||
struct diff_options *options = opt->value;
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
options->flags.relative_name = 1;
|
||||
if (arg)
|
||||
options->prefix = arg;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int diff_opt_unified(const struct option *opt,
|
||||
const char *arg, int unset)
|
||||
{
|
||||
@ -4957,6 +5062,9 @@ static void prep_parse_options(struct diff_options *options)
|
||||
OPT_BITOP('p', "patch", &options->output_format,
|
||||
N_("generate patch"),
|
||||
DIFF_FORMAT_PATCH, DIFF_FORMAT_NO_OUTPUT),
|
||||
OPT_BIT_F('s', "no-patch", &options->output_format,
|
||||
N_("suppress diff output"),
|
||||
DIFF_FORMAT_NO_OUTPUT, PARSE_OPT_NONEG),
|
||||
OPT_BITOP('u', NULL, &options->output_format,
|
||||
N_("generate patch"),
|
||||
DIFF_FORMAT_PATCH, DIFF_FORMAT_NO_OUTPUT),
|
||||
@ -4968,6 +5076,131 @@ static void prep_parse_options(struct diff_options *options)
|
||||
OPT_BIT_F(0, "raw", &options->output_format,
|
||||
N_("generate the diff in raw format"),
|
||||
DIFF_FORMAT_RAW, PARSE_OPT_NONEG),
|
||||
OPT_BITOP(0, "patch-with-raw", &options->output_format,
|
||||
N_("synonym for '-p --raw'"),
|
||||
DIFF_FORMAT_PATCH | DIFF_FORMAT_RAW,
|
||||
DIFF_FORMAT_NO_OUTPUT),
|
||||
OPT_BITOP(0, "patch-with-stat", &options->output_format,
|
||||
N_("synonym for '-p --stat'"),
|
||||
DIFF_FORMAT_PATCH | DIFF_FORMAT_DIFFSTAT,
|
||||
DIFF_FORMAT_NO_OUTPUT),
|
||||
OPT_BIT_F(0, "numstat", &options->output_format,
|
||||
N_("machine friendly --stat"),
|
||||
DIFF_FORMAT_NUMSTAT, PARSE_OPT_NONEG),
|
||||
OPT_BIT_F(0, "shortstat", &options->output_format,
|
||||
N_("output only the last line of --stat"),
|
||||
DIFF_FORMAT_SHORTSTAT, PARSE_OPT_NONEG),
|
||||
OPT_CALLBACK_F('X', "dirstat", options, N_("<param1,param2>..."),
|
||||
N_("output the distribution of relative amount of changes for each sub-directory"),
|
||||
PARSE_OPT_NONEG | PARSE_OPT_OPTARG,
|
||||
diff_opt_dirstat),
|
||||
OPT_CALLBACK_F(0, "cumulative", options, NULL,
|
||||
N_("synonym for --dirstat=cumulative"),
|
||||
PARSE_OPT_NONEG | PARSE_OPT_NOARG,
|
||||
diff_opt_dirstat),
|
||||
OPT_CALLBACK_F(0, "dirstat-by-file", options, N_("<param1,param2>..."),
|
||||
N_("synonym for --dirstat=files,param1,param2..."),
|
||||
PARSE_OPT_NONEG | PARSE_OPT_OPTARG,
|
||||
diff_opt_dirstat),
|
||||
OPT_BIT_F(0, "check", &options->output_format,
|
||||
N_("warn if changes introduce conflict markers or whitespace errors"),
|
||||
DIFF_FORMAT_CHECKDIFF, PARSE_OPT_NONEG),
|
||||
OPT_BIT_F(0, "summary", &options->output_format,
|
||||
N_("condensed summary such as creations, renames and mode changes"),
|
||||
DIFF_FORMAT_SUMMARY, PARSE_OPT_NONEG),
|
||||
OPT_BIT_F(0, "name-only", &options->output_format,
|
||||
N_("show only names of changed files"),
|
||||
DIFF_FORMAT_NAME, PARSE_OPT_NONEG),
|
||||
OPT_BIT_F(0, "name-status", &options->output_format,
|
||||
N_("show only names and status of changed files"),
|
||||
DIFF_FORMAT_NAME_STATUS, PARSE_OPT_NONEG),
|
||||
OPT_CALLBACK_F(0, "stat", options, N_("<width>[,<name-width>[,<count>]]"),
|
||||
N_("generate diffstat"),
|
||||
PARSE_OPT_NONEG | PARSE_OPT_OPTARG, diff_opt_stat),
|
||||
OPT_CALLBACK_F(0, "stat-width", options, N_("<width>"),
|
||||
N_("generate diffstat with a given width"),
|
||||
PARSE_OPT_NONEG, diff_opt_stat),
|
||||
OPT_CALLBACK_F(0, "stat-name-width", options, N_("<width>"),
|
||||
N_("generate diffstat with a given name width"),
|
||||
PARSE_OPT_NONEG, diff_opt_stat),
|
||||
OPT_CALLBACK_F(0, "stat-graph-width", options, N_("<width>"),
|
||||
N_("generate diffstat with a given graph width"),
|
||||
PARSE_OPT_NONEG, diff_opt_stat),
|
||||
OPT_CALLBACK_F(0, "stat-count", options, N_("<count>"),
|
||||
N_("generate diffstat with limited lines"),
|
||||
PARSE_OPT_NONEG, diff_opt_stat),
|
||||
OPT_CALLBACK_F(0, "compact-summary", options, NULL,
|
||||
N_("generate compact summary in diffstat"),
|
||||
PARSE_OPT_NOARG, diff_opt_compact_summary),
|
||||
OPT_CALLBACK_F(0, "output-indicator-new",
|
||||
&options->output_indicators[OUTPUT_INDICATOR_NEW],
|
||||
N_("<char>"),
|
||||
N_("specify the character to indicate a new line instead of '+'"),
|
||||
PARSE_OPT_NONEG, diff_opt_char),
|
||||
OPT_CALLBACK_F(0, "output-indicator-old",
|
||||
&options->output_indicators[OUTPUT_INDICATOR_OLD],
|
||||
N_("<char>"),
|
||||
N_("specify the character to indicate an old line instead of '-'"),
|
||||
PARSE_OPT_NONEG, diff_opt_char),
|
||||
OPT_CALLBACK_F(0, "output-indicator-context",
|
||||
&options->output_indicators[OUTPUT_INDICATOR_CONTEXT],
|
||||
N_("<char>"),
|
||||
N_("specify the character to indicate a context instead of ' '"),
|
||||
PARSE_OPT_NONEG, diff_opt_char),
|
||||
|
||||
OPT_GROUP(N_("Diff rename options")),
|
||||
OPT_CALLBACK_F('B', "break-rewrites", &options->break_opt, N_("<n>[/<m>]"),
|
||||
N_("break complete rewrite changes into pairs of delete and create"),
|
||||
PARSE_OPT_NONEG | PARSE_OPT_OPTARG,
|
||||
diff_opt_break_rewrites),
|
||||
OPT_CALLBACK_F('M', "find-renames", options, N_("<n>"),
|
||||
N_("detect renames"),
|
||||
PARSE_OPT_NONEG | PARSE_OPT_OPTARG,
|
||||
diff_opt_find_renames),
|
||||
OPT_SET_INT_F('D', "irreversible-delete", &options->irreversible_delete,
|
||||
N_("omit the preimage for deletes"),
|
||||
1, PARSE_OPT_NONEG),
|
||||
OPT_CALLBACK_F('C', "find-copies", options, N_("<n>"),
|
||||
N_("detect copies"),
|
||||
PARSE_OPT_NONEG | PARSE_OPT_OPTARG,
|
||||
diff_opt_find_copies),
|
||||
OPT_BOOL(0, "find-copies-harder", &options->flags.find_copies_harder,
|
||||
N_("use unmodified files as source to find copies")),
|
||||
OPT_SET_INT_F(0, "no-renames", &options->detect_rename,
|
||||
N_("disable rename detection"),
|
||||
0, PARSE_OPT_NONEG),
|
||||
OPT_BOOL(0, "rename-empty", &options->flags.rename_empty,
|
||||
N_("use empty blobs as rename source")),
|
||||
|
||||
OPT_GROUP(N_("Diff algorithm options")),
|
||||
OPT_BIT(0, "minimal", &options->xdl_opts,
|
||||
N_("produce the smallest possible diff"),
|
||||
XDF_NEED_MINIMAL),
|
||||
OPT_BIT_F('w', "ignore-all-space", &options->xdl_opts,
|
||||
N_("ignore whitespace when comparing lines"),
|
||||
XDF_IGNORE_WHITESPACE, PARSE_OPT_NONEG),
|
||||
OPT_BIT_F('b', "ignore-space-change", &options->xdl_opts,
|
||||
N_("ignore changes in amount of whitespace"),
|
||||
XDF_IGNORE_WHITESPACE_CHANGE, PARSE_OPT_NONEG),
|
||||
OPT_BIT_F(0, "ignore-space-at-eol", &options->xdl_opts,
|
||||
N_("ignore changes in whitespace at EOL"),
|
||||
XDF_IGNORE_WHITESPACE_AT_EOL, PARSE_OPT_NONEG),
|
||||
OPT_BIT_F(0, "ignore-cr-at-eol", &options->xdl_opts,
|
||||
N_("ignore carrier-return at the end of line"),
|
||||
XDF_IGNORE_CR_AT_EOL, PARSE_OPT_NONEG),
|
||||
OPT_BIT_F(0, "ignore-blank-lines", &options->xdl_opts,
|
||||
N_("ignore changes whose lines are all blank"),
|
||||
XDF_IGNORE_BLANK_LINES, PARSE_OPT_NONEG),
|
||||
|
||||
OPT_GROUP(N_("Diff other options")),
|
||||
OPT_CALLBACK_F(0, "relative", options, N_("<prefix>"),
|
||||
N_("when run from subdir, exclude changes outside and show relative paths"),
|
||||
PARSE_OPT_NONEG | PARSE_OPT_OPTARG,
|
||||
diff_opt_relative),
|
||||
{ OPTION_CALLBACK, 0, "output", options, N_("<file>"),
|
||||
N_("Output to a specific file"),
|
||||
PARSE_OPT_NONEG, NULL, 0, diff_opt_output },
|
||||
|
||||
OPT_END()
|
||||
};
|
||||
|
||||
@ -4995,102 +5228,8 @@ int diff_opt_parse(struct diff_options *options,
|
||||
if (ac)
|
||||
return ac;
|
||||
|
||||
/* Output format options */
|
||||
if (!strcmp(arg, "--patch-with-raw")) {
|
||||
enable_patch_output(&options->output_format);
|
||||
options->output_format |= DIFF_FORMAT_RAW;
|
||||
} else if (!strcmp(arg, "--numstat"))
|
||||
options->output_format |= DIFF_FORMAT_NUMSTAT;
|
||||
else if (!strcmp(arg, "--shortstat"))
|
||||
options->output_format |= DIFF_FORMAT_SHORTSTAT;
|
||||
else if (skip_prefix(arg, "-X", &arg) ||
|
||||
skip_to_optional_arg(arg, "--dirstat", &arg))
|
||||
return parse_dirstat_opt(options, arg);
|
||||
else if (!strcmp(arg, "--cumulative"))
|
||||
return parse_dirstat_opt(options, "cumulative");
|
||||
else if (skip_to_optional_arg(arg, "--dirstat-by-file", &arg)) {
|
||||
parse_dirstat_opt(options, "files");
|
||||
return parse_dirstat_opt(options, arg);
|
||||
}
|
||||
else if (!strcmp(arg, "--check"))
|
||||
options->output_format |= DIFF_FORMAT_CHECKDIFF;
|
||||
else if (!strcmp(arg, "--summary"))
|
||||
options->output_format |= DIFF_FORMAT_SUMMARY;
|
||||
else if (!strcmp(arg, "--patch-with-stat")) {
|
||||
enable_patch_output(&options->output_format);
|
||||
options->output_format |= DIFF_FORMAT_DIFFSTAT;
|
||||
} else if (!strcmp(arg, "--name-only"))
|
||||
options->output_format |= DIFF_FORMAT_NAME;
|
||||
else if (!strcmp(arg, "--name-status"))
|
||||
options->output_format |= DIFF_FORMAT_NAME_STATUS;
|
||||
else if (!strcmp(arg, "-s") || !strcmp(arg, "--no-patch"))
|
||||
options->output_format |= DIFF_FORMAT_NO_OUTPUT;
|
||||
else if (starts_with(arg, "--stat"))
|
||||
/* --stat, --stat-width, --stat-name-width, or --stat-count */
|
||||
return stat_opt(options, av);
|
||||
else if (!strcmp(arg, "--compact-summary")) {
|
||||
options->flags.stat_with_summary = 1;
|
||||
options->output_format |= DIFF_FORMAT_DIFFSTAT;
|
||||
} else if (!strcmp(arg, "--no-compact-summary"))
|
||||
options->flags.stat_with_summary = 0;
|
||||
else if (skip_prefix(arg, "--output-indicator-new=", &arg))
|
||||
options->output_indicators[OUTPUT_INDICATOR_NEW] = arg[0];
|
||||
else if (skip_prefix(arg, "--output-indicator-old=", &arg))
|
||||
options->output_indicators[OUTPUT_INDICATOR_OLD] = arg[0];
|
||||
else if (skip_prefix(arg, "--output-indicator-context=", &arg))
|
||||
options->output_indicators[OUTPUT_INDICATOR_CONTEXT] = arg[0];
|
||||
|
||||
/* renames options */
|
||||
else if (starts_with(arg, "-B") ||
|
||||
skip_to_optional_arg(arg, "--break-rewrites", NULL)) {
|
||||
if ((options->break_opt = diff_scoreopt_parse(arg)) == -1)
|
||||
return error("invalid argument to -B: %s", arg+2);
|
||||
}
|
||||
else if (starts_with(arg, "-M") ||
|
||||
skip_to_optional_arg(arg, "--find-renames", NULL)) {
|
||||
if ((options->rename_score = diff_scoreopt_parse(arg)) == -1)
|
||||
return error("invalid argument to -M: %s", arg+2);
|
||||
options->detect_rename = DIFF_DETECT_RENAME;
|
||||
}
|
||||
else if (!strcmp(arg, "-D") || !strcmp(arg, "--irreversible-delete")) {
|
||||
options->irreversible_delete = 1;
|
||||
}
|
||||
else if (starts_with(arg, "-C") ||
|
||||
skip_to_optional_arg(arg, "--find-copies", NULL)) {
|
||||
if (options->detect_rename == DIFF_DETECT_COPY)
|
||||
options->flags.find_copies_harder = 1;
|
||||
if ((options->rename_score = diff_scoreopt_parse(arg)) == -1)
|
||||
return error("invalid argument to -C: %s", arg+2);
|
||||
options->detect_rename = DIFF_DETECT_COPY;
|
||||
}
|
||||
else if (!strcmp(arg, "--no-renames"))
|
||||
options->detect_rename = 0;
|
||||
else if (!strcmp(arg, "--rename-empty"))
|
||||
options->flags.rename_empty = 1;
|
||||
else if (!strcmp(arg, "--no-rename-empty"))
|
||||
options->flags.rename_empty = 0;
|
||||
else if (skip_to_optional_arg_default(arg, "--relative", &arg, NULL)) {
|
||||
options->flags.relative_name = 1;
|
||||
if (arg)
|
||||
options->prefix = arg;
|
||||
}
|
||||
|
||||
/* xdiff options */
|
||||
else if (!strcmp(arg, "--minimal"))
|
||||
DIFF_XDL_SET(options, NEED_MINIMAL);
|
||||
else if (!strcmp(arg, "--no-minimal"))
|
||||
DIFF_XDL_CLR(options, NEED_MINIMAL);
|
||||
else if (!strcmp(arg, "-w") || !strcmp(arg, "--ignore-all-space"))
|
||||
DIFF_XDL_SET(options, IGNORE_WHITESPACE);
|
||||
else if (!strcmp(arg, "-b") || !strcmp(arg, "--ignore-space-change"))
|
||||
DIFF_XDL_SET(options, IGNORE_WHITESPACE_CHANGE);
|
||||
else if (!strcmp(arg, "--ignore-space-at-eol"))
|
||||
DIFF_XDL_SET(options, IGNORE_WHITESPACE_AT_EOL);
|
||||
else if (!strcmp(arg, "--ignore-cr-at-eol"))
|
||||
DIFF_XDL_SET(options, IGNORE_CR_AT_EOL);
|
||||
else if (!strcmp(arg, "--ignore-blank-lines"))
|
||||
DIFF_XDL_SET(options, IGNORE_BLANK_LINES);
|
||||
else if (!strcmp(arg, "--indent-heuristic"))
|
||||
if (!strcmp(arg, "--indent-heuristic"))
|
||||
DIFF_XDL_SET(options, INDENT_HEURISTIC);
|
||||
else if (!strcmp(arg, "--no-indent-heuristic"))
|
||||
DIFF_XDL_CLR(options, INDENT_HEURISTIC);
|
||||
@ -5135,8 +5274,6 @@ int diff_opt_parse(struct diff_options *options,
|
||||
options->flags.text = 1;
|
||||
else if (!strcmp(arg, "-R"))
|
||||
options->flags.reverse_diff = 1;
|
||||
else if (!strcmp(arg, "--find-copies-harder"))
|
||||
options->flags.find_copies_harder = 1;
|
||||
else if (!strcmp(arg, "--follow"))
|
||||
options->flags.follow_renames = 1;
|
||||
else if (!strcmp(arg, "--no-follow")) {
|
||||
@ -5284,15 +5421,7 @@ int diff_opt_parse(struct diff_options *options,
|
||||
else if (opt_arg(arg, '\0', "inter-hunk-context",
|
||||
&options->interhunkcontext))
|
||||
;
|
||||
else if ((argcount = parse_long_opt("output", av, &optarg))) {
|
||||
char *path = prefix_filename(prefix, optarg);
|
||||
options->file = xfopen(path, "w");
|
||||
options->close_file = 1;
|
||||
if (options->use_color != GIT_COLOR_ALWAYS)
|
||||
options->use_color = GIT_COLOR_NEVER;
|
||||
free(path);
|
||||
return argcount;
|
||||
} else
|
||||
else
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
@ -5333,47 +5462,6 @@ int parse_rename_score(const char **cp_p)
|
||||
return (int)((num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale));
|
||||
}
|
||||
|
||||
static int diff_scoreopt_parse(const char *opt)
|
||||
{
|
||||
int opt1, opt2, cmd;
|
||||
|
||||
if (*opt++ != '-')
|
||||
return -1;
|
||||
cmd = *opt++;
|
||||
if (cmd == '-') {
|
||||
/* convert the long-form arguments into short-form versions */
|
||||
if (skip_prefix(opt, "break-rewrites", &opt)) {
|
||||
if (*opt == 0 || *opt++ == '=')
|
||||
cmd = 'B';
|
||||
} else if (skip_prefix(opt, "find-copies", &opt)) {
|
||||
if (*opt == 0 || *opt++ == '=')
|
||||
cmd = 'C';
|
||||
} else if (skip_prefix(opt, "find-renames", &opt)) {
|
||||
if (*opt == 0 || *opt++ == '=')
|
||||
cmd = 'M';
|
||||
}
|
||||
}
|
||||
if (cmd != 'M' && cmd != 'C' && cmd != 'B')
|
||||
return -1; /* that is not a -M, -C, or -B option */
|
||||
|
||||
opt1 = parse_rename_score(&opt);
|
||||
if (cmd != 'B')
|
||||
opt2 = 0;
|
||||
else {
|
||||
if (*opt == 0)
|
||||
opt2 = 0;
|
||||
else if (*opt != '/')
|
||||
return -1; /* we expect -B80/99 or -B80 */
|
||||
else {
|
||||
opt++;
|
||||
opt2 = parse_rename_score(&opt);
|
||||
}
|
||||
}
|
||||
if (*opt != 0)
|
||||
return -1;
|
||||
return opt1 | (opt2 << 16);
|
||||
}
|
||||
|
||||
struct diff_queue_struct diff_queued_diff;
|
||||
|
||||
void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user