FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Introduce generic command options framework

Browse source 
This commit adds a generic command options framework, that makes it
easy enough to add '-'-style options to commands in a uniform way,
instead of each command implementing option parsing in its own way.

Options are defined in arrays of option_def objects (for option
definition), and the same options definitions are used for supporting
TAB completion, and also for generating the relevant help fragment of
the "help" command.  See the gdb::options::build_help function, which
returns a string with the result of replacing %OPTIONS% in a template
string with an auto-generated "help" string fragment for all the
passed-in options.

Since most options in GDB are in the form of "-OPT", with a single
dash, this is the format that the framework supports.

I like to think of gdb's "-OPT" as the equivalent to getopt's long
options format ("--OPT"), and gdb's "/" as the equivalent to getopt's
short options format.  getopt's short options format allows mixing
several one-character options, like "ls -als", kind of similar to
gdb's "x /FMT" and "disassemble /MOD", etc.  While with gdb's "-"
options, the option is expected to have a full name, and to be
abbreviatable.  E.g., "watch -location", "break -function main", etc.

This patch only deals with "-" options.  The above comment serves more
to disclose why I don't think we should support mixing several
unrelated options in a single "-" option invocation, like "thread
apply -qcs" instead of "thread apply -q -c -s".

The following patches will add uses of the infrastructure to several
key commands.  Most notably, "print", "compile print", "backtrace",
"frame apply" and "thread apply".  I tried to add options to several
commands in order to make sure the framework didn't leave that many
open holes open.

Options use the same type as set commands -- enum var_types.  So
boolean options are var_boolean, enum options are var_enum, etc.  The
idea is to share code between settings commands and command options.
The "print" options will be based on the "set print" commands, and
their names will be the same.  Actually, their definitions will be the
same too.  There is a function to create "set/show" commands from an
array for option definitions:

 /* Install set/show commands for options defined in OPTIONS.  DATA is
    a pointer to the structure that holds the data associated with the
    OPTIONS array.  */
 extern void add_setshow_cmds_for_options (command_class cmd_class, void *data,
					   gdb::array_view<const option_def> options,
					   struct cmd_list_element **set_list,
					   struct cmd_list_element **show_list);

That will be used by several following patches.

Other features:

 - You can use the "--" delimiter to explicitly indicate end of
   options.  Several existing commands use this token sequence for
   this effect already, so this just standardizes it.

 - You can shorten option names, as long as unambiguous.  Currently,
   some commands allow this (e.g., break -function), while others do
   not (thread apply all -ascending).  As GDB allows abbreviating
   command names and other things, it feels more GDB-ish to allow
   abbreviating option names too, to me.

 - For boolean options, 0/1 stands for off/on, just like with boolean
   "set" commands.

 - For boolean options, "true" is implied, just like with boolean "set
   commands.

These are the option types supported, with a few examples:

 - boolean options (var_boolean).  The option's argument is optional.

   (gdb) print -pretty on -- *obj
   (gdb) print -pretty off -- *obj
   (gdb) print -p -- *obj
   (gdb) print -p 0 -- *obj

 - flag options (like var_boolean, but no option argument (on/off))

   (gdb) thread apply all -s COMMAND

 - enum options  (var_enum)

   (gdb) bt -entry-values compact
   (gdb) bt -e c

 - uinteger options (var_uinteger)

   (gdb) print -elements 100 -- *obj
   (gdb) print -e 100 -- *obj
   (gdb) print -elements unlimited -- *obj
   (gdb) print -e u -- *obj

 - zuinteger-unlimited options (var_zuinteger_unlimited)

   (gdb) print -max-depth 100 -- obj
   (gdb) print -max-depth -1 -- obj
   (gdb) print -max-depth unlimited -- obj

Other var_types could be supported, of course.  These were just the
types that I needed for the commands that I ported over, in the
following patches.

It was interesting (and unfortunate) to find that we need at least 3
different modes to cover the existing commands:

- Commands that require ending options with "--" if you specify any
  option: "print" and "compile print".

- Commands that do not want to require "--", and want to error out if
  you specify an unknown option (i.e., an unknown argument that starts
  with '-'): "compile code" / "compile file".

- Commands that do not want to require "--", and want to process
  unknown options themselves: "bt", because of "bt -COUNT",
  "thread/frame apply", because "-" is a valid command.

The different behavior is encoded in the process_options_mode enum,
passed to process_options/complete_options.

For testing, this patch adds one representative maintenance command
for each of the process_options_mode values, that are used by the
testsuite to exercise the options framework:

 (gdb) maint test-options require-delimiter
 (gdb) maint test-options unknown-is-error
 (gdb) maint test-options unknown-is-operand

and adds another command to help with TAB-completion testing:

 (gdb) maint show test-options-completion-result

See their description at the top of the maint-test-options.c file.

Docs/NEWS are in a patch later in the series.

gdb/ChangeLog:
2019-06-13  Pedro Alves  <palves@redhat.com>

	* Makefile.in (SUBDIR_CLI_SRCS): Add cli/cli-option.c.
	(COMMON_SFILES): Add maint-test-settings.c.
	* cli/cli-decode.c (boolean_enums): New global, factored out from
	...
	(add_setshow_boolean_cmd): ... here.
	* cli/cli-decode.h (boolean_enums): Declare.
	* cli/cli-option.c: New file.
	* cli/cli-option.h: New file.
	* cli/cli-setshow.c (parse_cli_boolean_value(const char **)): New,
	factored out from ...
	(parse_cli_boolean_value(const char *)): ... this.
	(is_unlimited_literal): Change parameter type to pointer to
	pointer.  Adjust and advance ARG pointer.
	(parse_cli_var_uinteger, parse_cli_var_zuinteger_unlimited)
	(parse_cli_var_enum): New, factored out from ...
	(do_set_command): ... this.  Adjust.
	* cli/cli-setshow.h (parse_cli_boolean_value)
	(parse_cli_var_uinteger, parse_cli_var_zuinteger_unlimited)
	(parse_cli_var_enum): Declare.
	* cli/cli-utils.c: Include "cli/cli-option.h".
	(get_ulongest): New.
	* cli/cli-utils.h (get_ulongest): Declare.
	(check_for_argument): New overloads.
	* maint-test-options.c: New file.

gdb/testsuite/ChangeLog:
2019-06-13  Pedro Alves  <palves@redhat.com>

	* gdb.base/options.c: New file.
	* gdb.base/options.exp: New file.
This commit is contained in:
Pedro Alves 2019-06-13 00:06:53 +01:00
parent 2c722807a7
commit 9d0faba9f5
14 changed files with 2409 additions and 119 deletions
Download patch file Download diff file Expand all files Collapse all files

282
gdb/cli/cli-setshow.c
View file

@ -78,33 +78,48 @@ parse_auto_binary_operation (const char *arg)
/* See cli-setshow.h. */
int
parse_cli_boolean_value (const char *arg)
parse_cli_boolean_value (const char **arg)
{
int length;
if (!arg || !*arg)
return 1;
length = strlen (arg);
while (arg[length - 1] == ' ' || arg[length - 1] == '\t')
length--;
const char *p = skip_to_space (*arg);
size_t length = p - *arg;
/* Note that "o" is ambiguous. */
if ((length == 2 && strncmp (arg, "on", length) == 0)
|| strncmp (arg, "1", length) == 0
|| strncmp (arg, "yes", length) == 0
|| strncmp (arg, "enable", length) == 0)
return 1;
else if ((length >= 2 && strncmp (arg, "off", length) == 0)
|| strncmp (arg, "0", length) == 0
|| strncmp (arg, "no", length) == 0
|| strncmp (arg, "disable", length) == 0)
return 0;
if ((length == 2 && strncmp (*arg, "on", length) == 0)
|| strncmp (*arg, "1", length) == 0
|| strncmp (*arg, "yes", length) == 0
|| strncmp (*arg, "enable", length) == 0)
{
*arg = skip_spaces (*arg + length);
return 1;
}
else if ((length >= 2 && strncmp (*arg, "off", length) == 0)
|| strncmp (*arg, "0", length) == 0
|| strncmp (*arg, "no", length) == 0
|| strncmp (*arg, "disable", length) == 0)
{
*arg = skip_spaces (*arg + length);
return 0;
}
else
return -1;
}
/* See cli-setshow.h. */
int
parse_cli_boolean_value (const char *arg)
{
if (!arg || !*arg)
return 1;
int b = parse_cli_boolean_value (&arg);
if (b >= 0 && *arg != '\0')
return -1;
return b;
}
void
deprecated_show_value_hack (struct ui_file *ignore_file,
@ -134,21 +149,136 @@ deprecated_show_value_hack (struct ui_file *ignore_file,
/* Returns true if ARG is "unlimited". */
static int
is_unlimited_literal (const char *arg)
static bool
is_unlimited_literal (const char **arg)
{
arg = skip_spaces (arg);
*arg = skip_spaces (*arg);
const char *p = skip_to_space (arg);
const char *p = skip_to_space (*arg);
size_t len = p - arg;
size_t len = p - *arg;
if (len > 0 && strncmp ("unlimited", arg, len) == 0)
return true;
if (len > 0 && strncmp ("unlimited", *arg, len) == 0)
{
*arg += len;
return true;
}
return false;
}
/* See cli-setshow.h. */
unsigned int
parse_cli_var_uinteger (var_types var_type, const char **arg,
bool expression)
{
LONGEST val;
if (*arg == nullptr)
{
if (var_type == var_uinteger)
error_no_arg (_("integer to set it to, or \"unlimited\"."));
else
error_no_arg (_("integer to set it to."));
}
if (var_type == var_uinteger && is_unlimited_literal (arg))
val = 0;
else if (expression)
val = parse_and_eval_long (*arg);
else
val = get_ulongest (arg);
if (var_type == var_uinteger && val == 0)
val = UINT_MAX;
else if (val < 0
/* For var_uinteger, don't let the user set the value
to UINT_MAX directly, as that exposes an
implementation detail to the user interface. */
|| (var_type == var_uinteger && val >= UINT_MAX)
|| (var_type == var_zuinteger && val > UINT_MAX))
error (_("integer %s out of range"), plongest (val));
return val;
}
/* See cli-setshow.h. */
int
parse_cli_var_zuinteger_unlimited (const char **arg, bool expression)
{
LONGEST val;
if (*arg == nullptr)
error_no_arg (_("integer to set it to, or \"unlimited\"."));
if (is_unlimited_literal (arg))
val = -1;
else if (expression)
val = parse_and_eval_long (*arg);
else
val = get_ulongest (arg);
if (val > INT_MAX)
error (_("integer %s out of range"), plongest (val));
else if (val < -1)
error (_("only -1 is allowed to set as unlimited"));
return val;
}
/* See cli-setshow.h. */
const char *
parse_cli_var_enum (const char **args, const char *const *enums)
{
/* If no argument was supplied, print an informative error
message. */
if (args == NULL || *args == NULL || **args == '\0')
{
std::string msg;
for (size_t i = 0; enums[i]; i++)
{
if (i != 0)
msg += ", ";
msg += enums[i];
}
error (_("Requires an argument. Valid arguments are %s."),
msg.c_str ());
}
const char *p = skip_to_space (*args);
size_t len = p - *args;
int nmatches = 0;
const char *match = NULL;
for (size_t i = 0; enums[i]; i++)
if (strncmp (*args, enums[i], len) == 0)
{
if (enums[i][len] == '\0')
{
match = enums[i];
nmatches = 1;
break; /* Exact match. */
}
else
{
match = enums[i];
nmatches++;
}
}
if (nmatches == 0)
error (_("Undefined item: \"%.*s\"."), (int) len, *args);
if (nmatches > 1)
error (_("Ambiguous item \"%.*s\"."), (int) len, *args);
*args += len;
return match;
}
/* Do a "set" command. ARG is NULL if no argument, or the
text of the argument, and FROM_TTY is nonzero if this command is
@ -295,30 +425,7 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
case var_uinteger:
case var_zuinteger:
{
LONGEST val;
if (arg == NULL)
{
if (c->var_type == var_uinteger)
error_no_arg (_("integer to set it to, or \"unlimited\"."));
else
error_no_arg (_("integer to set it to."));
}
if (c->var_type == var_uinteger && is_unlimited_literal (arg))
val = 0;
else
val = parse_and_eval_long (arg);
if (c->var_type == var_uinteger && val == 0)
val = UINT_MAX;
else if (val < 0
/* For var_uinteger, don't let the user set the value
to UINT_MAX directly, as that exposes an
implementation detail to the user interface. */
|| (c->var_type == var_uinteger && val >= UINT_MAX)
|| (c->var_type == var_zuinteger && val > UINT_MAX))
error (_("integer %s out of range"), plongest (val));
unsigned int val = parse_cli_var_uinteger (c->var_type, &arg, true);
if (*(unsigned int *) c->var != val)
{
@ -341,7 +448,7 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
error_no_arg (_("integer to set it to."));
}
if (c->var_type == var_integer && is_unlimited_literal (arg))
if (c->var_type == var_integer && is_unlimited_literal (&arg))
val = 0;
else
val = parse_and_eval_long (arg);
@ -366,59 +473,11 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
}
case var_enum:
{
int i;
int len;
int nmatches;
const char *match = NULL;
const char *p;
const char *end_arg = arg;
const char *match = parse_cli_var_enum (&end_arg, c->enums);
/* If no argument was supplied, print an informative error
message. */
if (arg == NULL)
{
std::string msg;
for (i = 0; c->enums[i]; i++)
{
if (i != 0)
msg += ", ";
msg += c->enums[i];
}
error (_("Requires an argument. Valid arguments are %s."),
msg.c_str ());
}
p = strchr (arg, ' ');
if (p)
len = p - arg;
else
len = strlen (arg);
nmatches = 0;
for (i = 0; c->enums[i]; i++)
if (strncmp (arg, c->enums[i], len) == 0)
{
if (c->enums[i][len] == '\0')
{
match = c->enums[i];
nmatches = 1;
break; /* Exact match. */
}
else
{
match = c->enums[i];
nmatches++;
}
}
if (nmatches <= 0)
error (_("Undefined item: \"%s\"."), arg);
if (nmatches > 1)
error (_("Ambiguous item \"%s\"."), arg);
const char *after = skip_spaces (arg + len);
int len = end_arg - arg;
const char *after = skip_spaces (end_arg);
if (*after != '\0')
error (_("Junk after item \"%.*s\": %s"), len, arg, after);
@ -432,20 +491,7 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
break;
case var_zuinteger_unlimited:
{
LONGEST val;
if (arg == NULL)
error_no_arg (_("integer to set it to, or \"unlimited\"."));
if (is_unlimited_literal (arg))
val = -1;
else
val = parse_and_eval_long (arg);
if (val > INT_MAX)
error (_("integer %s out of range"), plongest (val));
else if (val < -1)
error (_("only -1 is allowed to set as unlimited"));
int val = parse_cli_var_zuinteger_unlimited (&arg, true);
if (*(int *) c->var != val)
{