mirror of
https://github.com/git/git
synced 2024-08-28 20:20:07 +00:00
![René Scharfe](/assets/img/avatar_default.png)
Only a single PARSE_OPT_CMDMODE option can be specified for the same variable at the same time. This is enforced by get_value(), but the error messages are imprecise in three ways: 1. If a non-PARSE_OPT_CMDMODE option changes the value variable of a PARSE_OPT_CMDMODE option then an ominously vague message is shown: $ t/helper/test-tool parse-options --set23 --mode1 error: option `mode1' : incompatible with something else Worse: If the order of options is reversed then no error is reported at all: $ t/helper/test-tool parse-options --mode1 --set23 boolean: 0 integer: 23 magnitude: 0 timestamp: 0 string: (not set) abbrev: 7 verbose: -1 quiet: 0 dry run: no file: (not set) Fortunately this can currently only happen in the test helper; actual Git commands don't share the same variable for the value of options with and without the flag PARSE_OPT_CMDMODE. 2. If there are multiple options with the same value (synonyms), then the one that is defined first is shown rather than the one actually given on the command line, which is confusing: $ git am --resolved --quit error: option `quit' is incompatible with --continue 3. Arguments of PARSE_OPT_CMDMODE options are not handled by the parse-option machinery. This is left to the callback function. We currently only have a single affected option, --show-current-patch of git am. Errors for it can show an argument that was not actually given on the command line: $ git am --show-current-patch --show-current-patch=diff error: options '--show-current-patch=diff' and '--show-current-patch=raw' cannot be used together The options --show-current-patch and --show-current-patch=raw are synonyms, but the error accuses the user of input they did not actually made. Or it can awkwardly print a NULL pointer: $ git am --show-current-patch=diff --show-current-patch error: options '--show-current-patch=(null)' and '--show-current-patch=diff' cannot be used together The reasons for these shortcomings is that the current code checks incompatibility only when encountering a PARSE_OPT_CMDMODE option at the command line, and that it searches the previous incompatible option by value. Fix the first two points by checking all PARSE_OPT_CMDMODE variables after parsing each option and by storing all relevant details if their value changed. Do that whether or not the changing options has the flag PARSE_OPT_CMDMODE set. Report an incompatibility only if two options change the variable to different values and at least one of them is a PARSE_OPT_CMDMODE option. This changes the output of the first three examples above to: $ t/helper/test-tool parse-options --set23 --mode1 error: --mode1 is incompatible with --set23 $ t/helper/test-tool parse-options --mode1 --set23 error: --set23 is incompatible with --mode1 $ git am --resolved --quit error: --quit is incompatible with --resolved Store the argument of PARSE_OPT_CMDMODE options of type OPTION_CALLBACK as well to allow taking over the responsibility for compatibility checking from the callback function. The next patch will use this capability to fix the messages for git am --show-current-patch. Use a linked list for storing the PARSE_OPT_CMDMODE variables. This somewhat outdated data structure is simple and suffices, as the number of elements per command is currently only zero or one. We do support multiple different command modes variables per command, but I don't expect that we'd ever use a significant number of them. Once we do we can switch to a hashmap. Since we no longer need to search the conflicting option, the all_opts parameter of get_value() is no longer used. Remove it. Extend the tests to check for both conflicting option names, but don't insist on a particular order. Signed-off-by: René Scharfe <l.s.r@web.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
341 lines
9.7 KiB
C
341 lines
9.7 KiB
C
#include "test-tool.h"
|
|
#include "parse-options.h"
|
|
#include "strbuf.h"
|
|
#include "string-list.h"
|
|
#include "trace2.h"
|
|
|
|
static int boolean = 0;
|
|
static int integer = 0;
|
|
static unsigned long magnitude = 0;
|
|
static timestamp_t timestamp;
|
|
static int abbrev = 7;
|
|
static int verbose = -1; /* unspecified */
|
|
static int dry_run = 0, quiet = 0;
|
|
static char *string = NULL;
|
|
static char *file = NULL;
|
|
static int ambiguous;
|
|
|
|
static struct {
|
|
int called;
|
|
const char *arg;
|
|
int unset;
|
|
} length_cb;
|
|
|
|
static int mode34_callback(const struct option *opt, const char *arg, int unset)
|
|
{
|
|
if (unset)
|
|
*(int *)opt->value = 0;
|
|
else if (!strcmp(arg, "3"))
|
|
*(int *)opt->value = 3;
|
|
else if (!strcmp(arg, "4"))
|
|
*(int *)opt->value = 4;
|
|
else
|
|
return error("invalid value for '%s': '%s'", "--mode34", arg);
|
|
return 0;
|
|
}
|
|
|
|
static int length_callback(const struct option *opt, const char *arg, int unset)
|
|
{
|
|
length_cb.called = 1;
|
|
length_cb.arg = arg;
|
|
length_cb.unset = unset;
|
|
|
|
if (unset)
|
|
return 1; /* do not support unset */
|
|
|
|
*(int *)opt->value = strlen(arg);
|
|
return 0;
|
|
}
|
|
|
|
static int number_callback(const struct option *opt, const char *arg, int unset)
|
|
{
|
|
BUG_ON_OPT_NEG(unset);
|
|
*(int *)opt->value = strtol(arg, NULL, 10);
|
|
return 0;
|
|
}
|
|
|
|
static int collect_expect(const struct option *opt, const char *arg, int unset)
|
|
{
|
|
struct string_list *expect;
|
|
struct string_list_item *item;
|
|
struct strbuf label = STRBUF_INIT;
|
|
const char *colon;
|
|
|
|
if (!arg || unset)
|
|
die("malformed --expect option");
|
|
|
|
expect = (struct string_list *)opt->value;
|
|
colon = strchr(arg, ':');
|
|
if (!colon)
|
|
die("malformed --expect option, lacking a colon");
|
|
strbuf_add(&label, arg, colon - arg);
|
|
item = string_list_insert(expect, strbuf_detach(&label, NULL));
|
|
if (item->util)
|
|
die("malformed --expect option, duplicate %s", label.buf);
|
|
item->util = (void *)arg;
|
|
return 0;
|
|
}
|
|
|
|
__attribute__((format (printf,3,4)))
|
|
static void show(struct string_list *expect, int *status, const char *fmt, ...)
|
|
{
|
|
struct string_list_item *item;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
va_list args;
|
|
|
|
va_start(args, fmt);
|
|
strbuf_vaddf(&buf, fmt, args);
|
|
va_end(args);
|
|
|
|
if (!expect->nr)
|
|
printf("%s\n", buf.buf);
|
|
else {
|
|
char *colon = strchr(buf.buf, ':');
|
|
if (!colon)
|
|
die("malformed output format, output lacking colon: %s", fmt);
|
|
*colon = '\0';
|
|
item = string_list_lookup(expect, buf.buf);
|
|
*colon = ':';
|
|
if (!item)
|
|
; /* not among entries being checked */
|
|
else {
|
|
if (strcmp((const char *)item->util, buf.buf)) {
|
|
printf("-%s\n", (char *)item->util);
|
|
printf("+%s\n", buf.buf);
|
|
*status = 1;
|
|
}
|
|
}
|
|
}
|
|
strbuf_release(&buf);
|
|
}
|
|
|
|
int cmd__parse_options(int argc, const char **argv)
|
|
{
|
|
const char *prefix = "prefix/";
|
|
const char *usage[] = {
|
|
"test-tool parse-options <options>",
|
|
"",
|
|
"A helper function for the parse-options API.",
|
|
NULL
|
|
};
|
|
struct string_list expect = STRING_LIST_INIT_NODUP;
|
|
struct string_list list = STRING_LIST_INIT_NODUP;
|
|
|
|
struct option options[] = {
|
|
OPT_BOOL(0, "yes", &boolean, "get a boolean"),
|
|
OPT_BOOL('D', "no-doubt", &boolean, "begins with 'no-'"),
|
|
{ OPTION_SET_INT, 'B', "no-fear", &boolean, NULL,
|
|
"be brave", PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, 1 },
|
|
OPT_COUNTUP('b', "boolean", &boolean, "increment by one"),
|
|
OPT_BIT('4', "or4", &boolean,
|
|
"bitwise-or boolean with ...0100", 4),
|
|
OPT_NEGBIT(0, "neg-or4", &boolean, "same as --no-or4", 4),
|
|
OPT_GROUP(""),
|
|
OPT_INTEGER('i', "integer", &integer, "get a integer"),
|
|
OPT_INTEGER('j', NULL, &integer, "get a integer, too"),
|
|
OPT_MAGNITUDE('m', "magnitude", &magnitude, "get a magnitude"),
|
|
OPT_SET_INT(0, "set23", &integer, "set integer to 23", 23),
|
|
OPT_CMDMODE(0, "mode1", &integer, "set integer to 1 (cmdmode option)", 1),
|
|
OPT_CMDMODE(0, "mode2", &integer, "set integer to 2 (cmdmode option)", 2),
|
|
OPT_CALLBACK_F(0, "mode34", &integer, "(3|4)",
|
|
"set integer to 3 or 4 (cmdmode option)",
|
|
PARSE_OPT_CMDMODE, mode34_callback),
|
|
OPT_CALLBACK('L', "length", &integer, "str",
|
|
"get length of <str>", length_callback),
|
|
OPT_FILENAME('F', "file", &file, "set file to <file>"),
|
|
OPT_GROUP("String options"),
|
|
OPT_STRING('s', "string", &string, "string", "get a string"),
|
|
OPT_STRING(0, "string2", &string, "str", "get another string"),
|
|
OPT_STRING(0, "st", &string, "st", "get another string (pervert ordering)"),
|
|
OPT_STRING('o', NULL, &string, "str", "get another string"),
|
|
OPT_NOOP_NOARG(0, "obsolete"),
|
|
OPT_SET_INT_F(0, "longhelp", &integer, "help text of this entry\n"
|
|
"spans multiple lines", 0, PARSE_OPT_NONEG),
|
|
OPT_STRING_LIST(0, "list", &list, "str", "add str to list"),
|
|
OPT_GROUP("Magic arguments"),
|
|
OPT_NUMBER_CALLBACK(&integer, "set integer to NUM",
|
|
number_callback),
|
|
{ OPTION_COUNTUP, '+', NULL, &boolean, NULL, "same as -b",
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH },
|
|
{ OPTION_COUNTUP, 0, "ambiguous", &ambiguous, NULL,
|
|
"positive ambiguity", PARSE_OPT_NOARG | PARSE_OPT_NONEG },
|
|
{ OPTION_COUNTUP, 0, "no-ambiguous", &ambiguous, NULL,
|
|
"negative ambiguity", PARSE_OPT_NOARG | PARSE_OPT_NONEG },
|
|
OPT_GROUP("Standard options"),
|
|
OPT__ABBREV(&abbrev),
|
|
OPT__VERBOSE(&verbose, "be verbose"),
|
|
OPT__DRY_RUN(&dry_run, "dry run"),
|
|
OPT__QUIET(&quiet, "be quiet"),
|
|
OPT_CALLBACK(0, "expect", &expect, "string",
|
|
"expected output in the variable dump",
|
|
collect_expect),
|
|
OPT_GROUP("Alias"),
|
|
OPT_STRING('A', "alias-source", &string, "string", "get a string"),
|
|
OPT_ALIAS('Z', "alias-target", "alias-source"),
|
|
OPT_END(),
|
|
};
|
|
int i;
|
|
int ret = 0;
|
|
|
|
trace2_cmd_name("_parse_");
|
|
|
|
argc = parse_options(argc, (const char **)argv, prefix, options, usage, 0);
|
|
|
|
if (length_cb.called) {
|
|
const char *arg = length_cb.arg;
|
|
int unset = length_cb.unset;
|
|
show(&expect, &ret, "Callback: \"%s\", %d",
|
|
(arg ? arg : "not set"), unset);
|
|
}
|
|
show(&expect, &ret, "boolean: %d", boolean);
|
|
show(&expect, &ret, "integer: %d", integer);
|
|
show(&expect, &ret, "magnitude: %lu", magnitude);
|
|
show(&expect, &ret, "timestamp: %"PRItime, timestamp);
|
|
show(&expect, &ret, "string: %s", string ? string : "(not set)");
|
|
show(&expect, &ret, "abbrev: %d", abbrev);
|
|
show(&expect, &ret, "verbose: %d", verbose);
|
|
show(&expect, &ret, "quiet: %d", quiet);
|
|
show(&expect, &ret, "dry run: %s", dry_run ? "yes" : "no");
|
|
show(&expect, &ret, "file: %s", file ? file : "(not set)");
|
|
|
|
for (i = 0; i < list.nr; i++)
|
|
show(&expect, &ret, "list: %s", list.items[i].string);
|
|
|
|
for (i = 0; i < argc; i++)
|
|
show(&expect, &ret, "arg %02d: %s", i, argv[i]);
|
|
|
|
expect.strdup_strings = 1;
|
|
string_list_clear(&expect, 0);
|
|
string_list_clear(&list, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void print_args(int argc, const char **argv)
|
|
{
|
|
int i;
|
|
for (i = 0; i < argc; i++)
|
|
printf("arg %02d: %s\n", i, argv[i]);
|
|
}
|
|
|
|
static int parse_options_flags__cmd(int argc, const char **argv,
|
|
enum parse_opt_flags test_flags)
|
|
{
|
|
const char *usage[] = {
|
|
"<...> cmd [options]",
|
|
NULL
|
|
};
|
|
int opt = 0;
|
|
const struct option options[] = {
|
|
OPT_INTEGER('o', "opt", &opt, "an integer option"),
|
|
OPT_END()
|
|
};
|
|
|
|
argc = parse_options(argc, argv, NULL, options, usage, test_flags);
|
|
|
|
printf("opt: %d\n", opt);
|
|
print_args(argc, argv);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static enum parse_opt_flags test_flags = 0;
|
|
static const struct option test_flag_options[] = {
|
|
OPT_GROUP("flag-options:"),
|
|
OPT_BIT(0, "keep-dashdash", &test_flags,
|
|
"pass PARSE_OPT_KEEP_DASHDASH to parse_options()",
|
|
PARSE_OPT_KEEP_DASHDASH),
|
|
OPT_BIT(0, "stop-at-non-option", &test_flags,
|
|
"pass PARSE_OPT_STOP_AT_NON_OPTION to parse_options()",
|
|
PARSE_OPT_STOP_AT_NON_OPTION),
|
|
OPT_BIT(0, "keep-argv0", &test_flags,
|
|
"pass PARSE_OPT_KEEP_ARGV0 to parse_options()",
|
|
PARSE_OPT_KEEP_ARGV0),
|
|
OPT_BIT(0, "keep-unknown-opt", &test_flags,
|
|
"pass PARSE_OPT_KEEP_UNKNOWN_OPT to parse_options()",
|
|
PARSE_OPT_KEEP_UNKNOWN_OPT),
|
|
OPT_BIT(0, "no-internal-help", &test_flags,
|
|
"pass PARSE_OPT_NO_INTERNAL_HELP to parse_options()",
|
|
PARSE_OPT_NO_INTERNAL_HELP),
|
|
OPT_BIT(0, "subcommand-optional", &test_flags,
|
|
"pass PARSE_OPT_SUBCOMMAND_OPTIONAL to parse_options()",
|
|
PARSE_OPT_SUBCOMMAND_OPTIONAL),
|
|
OPT_END()
|
|
};
|
|
|
|
int cmd__parse_options_flags(int argc, const char **argv)
|
|
{
|
|
const char *usage[] = {
|
|
"test-tool parse-options-flags [flag-options] cmd [options]",
|
|
NULL
|
|
};
|
|
|
|
argc = parse_options(argc, argv, NULL, test_flag_options, usage,
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
if (!argc || strcmp(argv[0], "cmd")) {
|
|
error("'cmd' is mandatory");
|
|
usage_with_options(usage, test_flag_options);
|
|
}
|
|
|
|
return parse_options_flags__cmd(argc, argv, test_flags);
|
|
}
|
|
|
|
static int subcmd_one(int argc, const char **argv, const char *prefix UNUSED)
|
|
{
|
|
printf("fn: subcmd_one\n");
|
|
print_args(argc, argv);
|
|
return 0;
|
|
}
|
|
|
|
static int subcmd_two(int argc, const char **argv, const char *prefix UNUSED)
|
|
{
|
|
printf("fn: subcmd_two\n");
|
|
print_args(argc, argv);
|
|
return 0;
|
|
}
|
|
|
|
static int parse_subcommand__cmd(int argc, const char **argv,
|
|
enum parse_opt_flags test_flags)
|
|
{
|
|
const char *usage[] = {
|
|
"<...> cmd subcmd-one",
|
|
"<...> cmd subcmd-two",
|
|
NULL
|
|
};
|
|
parse_opt_subcommand_fn *fn = NULL;
|
|
int opt = 0;
|
|
struct option options[] = {
|
|
OPT_SUBCOMMAND("subcmd-one", &fn, subcmd_one),
|
|
OPT_SUBCOMMAND("subcmd-two", &fn, subcmd_two),
|
|
OPT_INTEGER('o', "opt", &opt, "an integer option"),
|
|
OPT_END()
|
|
};
|
|
|
|
if (test_flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)
|
|
fn = subcmd_one;
|
|
argc = parse_options(argc, argv, NULL, options, usage, test_flags);
|
|
|
|
printf("opt: %d\n", opt);
|
|
|
|
return fn(argc, argv, NULL);
|
|
}
|
|
|
|
int cmd__parse_subcommand(int argc, const char **argv)
|
|
{
|
|
const char *usage[] = {
|
|
"test-tool parse-subcommand [flag-options] cmd <subcommand>",
|
|
NULL
|
|
};
|
|
|
|
argc = parse_options(argc, argv, NULL, test_flag_options, usage,
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
if (!argc || strcmp(argv[0], "cmd")) {
|
|
error("'cmd' is mandatory");
|
|
usage_with_options(usage, test_flag_options);
|
|
}
|
|
|
|
return parse_subcommand__cmd(argc, argv, test_flags);
|
|
}
|