[v2,12/24] Introduce generic command options framework

Message ID 20190530195333.20448-13-palves@redhat.com
State Superseded
Headers show
Series
  • gdb::option framework, "print -OPT", other cmd options
Related show

Commit Message

Pedro Alves May 30, 2019, 7:53 p.m.
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/testsuite/ChangeLog:
yyyy-mm-dd  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:
yyyy-mm-dd  Pedro Alves  <palves@redhat.com>

	* gdb.base/options.c: New file.
	* gdb.base/options.exp: New file.
---
 gdb/Makefile.in                    |   2 +
 gdb/cli/cli-decode.c               |   5 +-
 gdb/cli/cli-decode.h               |   4 +
 gdb/cli/cli-option.c               | 732 +++++++++++++++++++++++++++++++++++++
 gdb/cli/cli-option.h               | 335 +++++++++++++++++
 gdb/cli/cli-setshow.c              | 280 ++++++++------
 gdb/cli/cli-setshow.h              |  27 ++
 gdb/cli/cli-utils.c                |  51 +++
 gdb/cli/cli-utils.h                |  18 +
 gdb/maint-test-options.c           | 460 +++++++++++++++++++++++
 gdb/testsuite/gdb.base/options.c   |  33 ++
 gdb/testsuite/gdb.base/options.exp | 554 ++++++++++++++++++++++++++++
 12 files changed, 2383 insertions(+), 118 deletions(-)
 create mode 100644 gdb/cli/cli-option.c
 create mode 100644 gdb/cli/cli-option.h
 create mode 100644 gdb/maint-test-options.c
 create mode 100644 gdb/testsuite/gdb.base/options.c
 create mode 100644 gdb/testsuite/gdb.base/options.exp

-- 
2.14.5

Comments

Tom Tromey June 3, 2019, 7:16 p.m. | #1
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:


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

This all seems reasonable to me.  Thanks for taking this on.

Pedro> +/* Dup STR and return a unique_xmalloc_ptr for the result.  */
Pedro> +
Pedro> +static gdb::unique_xmalloc_ptr<char>
Pedro> +make_unique_xstrdup (const char *str)
Pedro> +{
Pedro> +  return gdb::unique_xmalloc_ptr<char> (xstrdup (str));
Pedro> +}

I could 25 spots that could use this, so how about putting it into a
header somewhere?  I am happy to convert all the existing uses.

Pedro> +  if (len > 0 && strncmp ("unlimited", *arg, len) == 0)

I should have mentioned this in an earlier patch, but won't this also
match things like "unlimitedjunk"?

Tom
Pedro Alves June 4, 2019, 9:37 p.m. | #2
On 6/3/19 8:16 PM, Tom Tromey wrote:
> 

> Pedro> +  if (len > 0 && strncmp ("unlimited", *arg, len) == 0)

> 

> I should have mentioned this in an earlier patch, but won't this also

> match things like "unlimitedjunk"?


It won't -- the code reads:

 static int
 is_unlimited_literal (const char *arg)
 {
   arg = skip_spaces (arg);

   const char *p = skip_to_space (arg);

   size_t len = p - arg;

   if (len > 0 && strncmp ("unlimited", arg, len) == 0)
     return true;

   return false;
 }

So for "unlimitedjunk", LEN will be 13, which is longer than
strlen ("unlimited"), so the strncmp returns != 0.

Thanks for bringing this up -- I missed adding a test for that
case.  I'm adding the below to the new settings.exp testcase.

Also, while writing the test I realized that we don't error
out with:

  (gdb) maint test-settings set uinteger unlimited junk

I wrote a follow up patch on top of the series to fix that.

Thanks,
Pedro Alves

diff --git c/gdb/testsuite/gdb.base/settings.exp w/gdb/testsuite/gdb.base/settings.exp
index 36c80086a3d..c62957181e2 100644
--- c/gdb/testsuite/gdb.base/settings.exp
+++ w/gdb/testsuite/gdb.base/settings.exp
@@ -141,7 +141,10 @@ proc test-integer {variant} {
            "$set_cmd unlimited"
     }
 
+    gdb_test "$set_cmd unlimitedu" "No symbol table is loaded.*"
+
     test_gdb_complete_none "$set_cmd unlimited "
+    test_gdb_complete_none "$set_cmd unlimitedu"

Patch

diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index e44df54ddea..88ae024bbd8 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -241,6 +241,7 @@  SUBDIR_CLI_SRCS = \
 	cli/cli-dump.c \
 	cli/cli-interp.c \
 	cli/cli-logging.c \
+	cli/cli-option.c \
 	cli/cli-script.c \
 	cli/cli-setshow.c \
 	cli/cli-style.c \
@@ -1062,6 +1063,7 @@  COMMON_SFILES = \
 	macrotab.c \
 	main.c \
 	maint.c \
+	maint-test-options.c \
 	maint-test-settings.c \
 	mdebugread.c \
 	mem-break.c \
diff --git a/gdb/cli/cli-decode.c b/gdb/cli/cli-decode.c
index 80158593b38..0370b125615 100644
--- a/gdb/cli/cli-decode.c
+++ b/gdb/cli/cli-decode.c
@@ -550,6 +550,7 @@  add_setshow_enum_cmd (const char *name,
   set_cmd_context (show, context);
 }
 
+/* See cli-decode.h.  */
 const char * const auto_boolean_enums[] = { "on", "off", "auto", NULL };
 
 /* Add an auto-boolean command named NAME to both the set and show
@@ -577,6 +578,9 @@  add_setshow_auto_boolean_cmd (const char *name,
   c->enums = auto_boolean_enums;
 }
 
+/* See cli-decode.h.  */
+const char * const boolean_enums[] = { "on", "off", NULL };
+
 /* Add element named NAME to both the set and show command LISTs (the
    list for set/show or some sublist thereof).  CLASS is as in
    add_cmd.  VAR is address of the variable which will contain the
@@ -590,7 +594,6 @@  add_setshow_boolean_cmd (const char *name, enum command_class theclass, int *var
 			 struct cmd_list_element **set_list,
 			 struct cmd_list_element **show_list)
 {
-  static const char *boolean_enums[] = { "on", "off", NULL };
   struct cmd_list_element *c;
 
   add_setshow_cmd_full (name, theclass, var_boolean, var,
diff --git a/gdb/cli/cli-decode.h b/gdb/cli/cli-decode.h
index c53683d95c0..13b4d26dd1d 100644
--- a/gdb/cli/cli-decode.h
+++ b/gdb/cli/cli-decode.h
@@ -261,6 +261,10 @@  extern void not_just_help_class_command (const char *arg, int from_tty);
 
 extern void print_doc_line (struct ui_file *, const char *);
 
+/* The enums of boolean commands.  */
+extern const char * const boolean_enums[];
+
+/* The enums of auto-boolean commands.  */
 extern const char * const auto_boolean_enums[];
 
 /* Verify whether a given cmd_list_element is a user-defined command.
diff --git a/gdb/cli/cli-option.c b/gdb/cli/cli-option.c
new file mode 100644
index 00000000000..9793dd5727e
--- /dev/null
+++ b/gdb/cli/cli-option.c
@@ -0,0 +1,732 @@ 
+/* CLI options framework, for GDB.
+
+   Copyright (C) 2017-2019 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "defs.h"
+#include "cli/cli-option.h"
+#include "cli/cli-decode.h"
+#include "cli/cli-utils.h"
+#include "cli/cli-setshow.h"
+#include "command.h"
+#include <vector>
+
+namespace gdb {
+namespace option {
+
+/* An option's value.  Which field is active depends on the option's
+   type.  */
+union option_value
+{
+  /* For var_boolean options.  */
+  bool boolean;
+
+  /* For var_uinteger options.  */
+  unsigned int uinteger;
+
+  /* For var_zuinteger_unlimited options.  */
+  int integer;
+
+  /* For var_enum options.  */
+  const char *enumeration;
+};
+
+/* Holds an options definition and its value.  */
+struct option_def_and_value
+{
+  /* The option definition.  */
+  const option_def &option;
+
+  /* A context.  */
+  void *ctx;
+
+  /* The option's value, if any.  */
+  gdb::optional<option_value> value;
+};
+
+/* Info passed around when handling completion.  */
+struct parse_option_completion_info
+{
+  /* The completion word.  */
+  const char *word;
+
+  /* The tracker.  */
+  completion_tracker &tracker;
+};
+
+/* If ARGS starts with "-", look for a "--" delimiter.  If one is
+   found, then interpret everything up until the "--" as command line
+   options.  Otherwise, interpret unknown input as the beginning of
+   the command's operands.  */
+
+static const char *
+find_end_options_delimiter (const char *args)
+{
+  if (args[0] == '-')
+    {
+      const char *p = args;
+
+      p = skip_spaces (p);
+      while (*p)
+	{
+	  if (check_for_argument (&p, "--"))
+	    return p;
+	  else
+	    p = skip_to_space (p);
+	  p = skip_spaces (p);
+	}
+    }
+
+  return nullptr;
+}
+
+/* Complete TEXT/WORD on all options in OPTIONS_GROUP.  */
+
+static void
+complete_on_options (gdb::array_view<const option_def_group> options_group,
+		     completion_tracker &tracker,
+		     const char *text, const char *word)
+{
+  size_t textlen = strlen (text);
+  for (const auto &grp : options_group)
+    for (const auto &opt : grp.options)
+      if (strncmp (opt.name, text, textlen) == 0)
+	{
+	  tracker.add_completion
+	    (make_completion_match_str (opt.name, text, word));
+	}
+}
+
+/* See cli-option.h.  */
+
+void
+complete_on_all_options (completion_tracker &tracker,
+			 gdb::array_view<const option_def_group> options_group)
+{
+  static const char opt[] = "-";
+  complete_on_options (options_group, tracker, opt + 1, opt);
+}
+
+/* Dup STR and return a unique_xmalloc_ptr for the result.  */
+
+static gdb::unique_xmalloc_ptr<char>
+make_unique_xstrdup (const char *str)
+{
+  return gdb::unique_xmalloc_ptr<char> (xstrdup (str));
+}
+
+/* Parse ARGS, guided by OPTIONS_GROUP.  HAVE_DELIMITER is true if the
+   whole ARGS line included the "--" options-terminator delimiter.  */
+
+static gdb::optional<option_def_and_value>
+parse_option (gdb::array_view<const option_def_group> options_group,
+	      process_options_mode mode,
+	      bool have_delimiter,
+	      const char **args,
+	      parse_option_completion_info *completion = nullptr)
+{
+  if (*args == nullptr)
+    return {};
+  else if (**args != '-')
+    {
+      if (have_delimiter)
+	error (_("Unrecognized option at: %s"), *args);
+      return {};
+    }
+  else if (check_for_argument (args, "--"))
+    return {};
+
+  /* Skip the initial '-'.  */
+  const char *arg = *args + 1;
+
+  const char *after = skip_to_space (arg);
+  size_t len = after - arg;
+  const option_def *match = nullptr;
+  void *match_ctx;
+
+  for (const auto &grp : options_group)
+    {
+      for (const auto &o : grp.options)
+	{
+	  if (strncmp (o.name, arg, len) == 0)
+	    {
+	      if (match != nullptr)
+		{
+		  if (completion != nullptr && arg[len] == '\0')
+		    {
+		      complete_on_options (options_group,
+					   completion->tracker,
+					   arg, completion->word);
+		      return {};
+		    }
+
+		  error (_("Ambiguous option at: -%s"), arg);
+		}
+
+	      match = &o;
+	      match_ctx = grp.ctx;
+
+	      if ((isspace (arg[len]) || arg[len] == '\0')
+		  && strlen (o.name) == len)
+		break; /* Exact match.  */
+	    }
+	}
+    }
+
+  if (match == nullptr)
+    {
+      if (have_delimiter || mode != PROCESS_OPTIONS_UNKNOWN_IS_OPERAND)
+	error (_("Unrecognized option at: %s"), *args);
+
+      return {};
+    }
+
+  if (completion != nullptr && arg[len] == '\0')
+    {
+      complete_on_options (options_group, completion->tracker,
+			   arg, completion->word);
+      return {};
+    }
+
+  *args += 1 + len;
+  *args = skip_spaces (*args);
+  if (completion != nullptr)
+    completion->word = *args;
+
+  switch (match->type)
+    {
+    case var_boolean:
+      {
+	if (!match->have_argument)
+	  {
+	    option_value val;
+	    val.boolean = true;
+	    return option_def_and_value {*match, match_ctx, val};
+	  }
+
+	const char *val_str = *args;
+	int res;
+
+	if (**args == '\0' && completion != nullptr)
+	  {
+	    /* Complete on both "on/off" and more options.  */
+
+	    if (mode == PROCESS_OPTIONS_REQUIRE_DELIMITER)
+	      {
+		complete_on_enum (completion->tracker,
+				  boolean_enums, val_str, val_str);
+		complete_on_all_options (completion->tracker, options_group);
+	      }
+	    return option_def_and_value {*match, match_ctx};
+	  }
+	else if (**args == '-')
+	  {
+	    /* Treat:
+		 "cmd -boolean-option -another-opt..."
+	       as:
+		 "cmd -boolean-option on -another-opt..."
+	     */
+	    res = 1;
+	  }
+	else if (**args == '\0')
+	  {
+	    /* Treat:
+		 (1) "cmd -boolean-option "
+	       as:
+		 (1) "cmd -boolean-option on"
+	     */
+	    res = 1;
+	  }
+	else
+	  {
+	    res = parse_cli_boolean_value (args);
+	    if (res < 0)
+	      {
+		const char *end = skip_to_space (*args);
+		if (completion != nullptr)
+		  {
+		    if (*end == '\0')
+		      {
+			complete_on_enum (completion->tracker,
+					  boolean_enums, val_str, val_str);
+			return option_def_and_value {*match, match_ctx};
+		      }
+		  }
+
+		if (have_delimiter)
+		  error (_("Value given for `-%s' is not a boolean: %.*s"),
+			 match->name, (int) (end - val_str), val_str);
+		/* The user didn't separate options from operands
+		   using "--", so treat this unrecognized value as the
+		   start of the operands.  This makes "frame apply all
+		   -past-main CMD" work.  */
+		return option_def_and_value {*match, match_ctx};
+	      }
+	    else if (completion != nullptr && **args == '\0')
+	      {
+		/* While "cmd -boolean [TAB]" only offers "on" and
+		   "off", the boolean option actually accepts "1",
+		   "yes", etc. as boolean values.  We complete on all
+		   of those instead of BOOLEAN_ENUMS here to make
+		   these work:
+
+		    "p -object 1[TAB]" -> "p -object 1 "
+		    "p -object ye[TAB]" -> "p -object yes "
+
+		   Etc.  Note that it's important that the space is
+		   auto-appended.  Otherwise, if we only completed on
+		   on/off here, then it might look to the user like
+		   "1" isn't valid, like:
+		   "p -object 1[TAB]" -> "p -object 1" (i.e., nothing happens).
+		*/
+		static const char *const all_boolean_enums[] = {
+		  "on", "off",
+		  "yes", "no",
+		  "enable", "disable",
+		  "0", "1",
+		  nullptr,
+		};
+		complete_on_enum (completion->tracker, all_boolean_enums,
+				  val_str, val_str);
+		return {};
+	      }
+	  }
+
+	option_value val;
+	val.boolean = res;
+	return option_def_and_value {*match, match_ctx, val};
+      }
+    case var_uinteger:
+    case var_zuinteger_unlimited:
+      {
+	if (completion != nullptr)
+	  {
+	    if (**args == '\0')
+	      {
+		/* Convenience to let the user know what the option
+		   can accept.  Note there's no common prefix between
+		   the strings on purpose, so that readline doesn't do
+		   a partial match.  */
+		completion->tracker.add_completion
+		  (make_unique_xstrdup ("NUMBER"));
+		completion->tracker.add_completion
+		  (make_unique_xstrdup ("unlimited"));
+		return {};
+	      }
+	    else if (startswith ("unlimited", *args))
+	      {
+		completion->tracker.add_completion
+		  (make_unique_xstrdup ("unlimited"));
+		return {};
+	      }
+	  }
+
+	if (match->type == var_zuinteger_unlimited)
+	  {
+	    option_value val;
+	    val.integer = parse_cli_var_zuinteger_unlimited (args, false);
+	    return option_def_and_value {*match, match_ctx, val};
+	  }
+	else
+	  {
+	    option_value val;
+	    val.uinteger = parse_cli_var_uinteger (match->type, args, false);
+	    return option_def_and_value {*match, match_ctx, val};
+	  }
+      }
+    case var_enum:
+      {
+	if (completion != nullptr)
+	  {
+	    const char *after_arg = skip_to_space (*args);
+	    if (*after_arg == '\0')
+	      {
+		complete_on_enum (completion->tracker,
+				  match->enums, *args, *args);
+		*args = after_arg;
+
+		option_value val;
+		val.enumeration = nullptr;
+		return option_def_and_value {*match, match_ctx, val};
+	      }
+	  }
+
+	if (check_for_argument (args, "--"))
+	  {
+	    /* Treat e.g., "backtrace -entry-values --" as if there
+	       was no argument after "-entry-values".  This makes
+	       parse_cli_var_enum throw an error with a suggestion of
+	       what are the valid options.  */
+	    args = nullptr;
+	  }
+
+	option_value val;
+	val.enumeration = parse_cli_var_enum (args, match->enums);
+	return option_def_and_value {*match, match_ctx, val};
+      }
+
+    default:
+      /* Not yet.  */
+      gdb_assert_not_reached (_("option type not supported"));
+    }
+
+  return {};
+}
+
+/* See cli-option.h.  */
+
+bool
+complete_options (completion_tracker &tracker,
+		  const char **args,
+		  process_options_mode mode,
+		  gdb::array_view<const option_def_group> options_group)
+{
+  const char *text = *args;
+
+  tracker.set_use_custom_word_point (true);
+
+  const char *delimiter = find_end_options_delimiter (text);
+  bool have_delimiter = delimiter != nullptr;
+
+  if (text[0] == '-' && (!have_delimiter || *delimiter == '\0'))
+    {
+      parse_option_completion_info completion_info {nullptr, tracker};
+
+      while (1)
+	{
+	  *args = skip_spaces (*args);
+	  completion_info.word = *args;
+
+	  if (strcmp (*args, "-") == 0)
+	    {
+	      complete_on_options (options_group, tracker, *args + 1,
+				   completion_info.word);
+	    }
+	  else if (strcmp (*args, "--") == 0)
+	    {
+	      tracker.add_completion (make_unique_xstrdup (*args));
+	    }
+	  else if (**args == '-')
+	    {
+	      gdb::optional<option_def_and_value> ov
+		= parse_option (options_group, mode, have_delimiter,
+				args, &completion_info);
+	      if (!ov && !tracker.have_completions ())
+		{
+		  tracker.advance_custom_word_point_by (*args - text);
+		  return mode == PROCESS_OPTIONS_REQUIRE_DELIMITER;
+		}
+
+	      if (ov
+		  && ov->option.type == var_boolean
+		  && !ov->value.has_value ())
+		{
+		  /* Looked like a boolean option, but we failed to
+		     parse the value.  If this command requires a
+		     delimiter, this value can't be the start of the
+		     operands, so return true.  Otherwise, if the
+		     command doesn't require a delimiter return false
+		     so that the caller tries to complete on the
+		     operand.  */
+		  tracker.advance_custom_word_point_by (*args - text);
+		  return mode == PROCESS_OPTIONS_REQUIRE_DELIMITER;
+		}
+
+	      /* If we parsed an option with an argument, and reached
+		 the end of the input string with no trailing space,
+		 return true, so that our callers don't try to
+		 complete anything by themselves.  E.g., this makes it
+		 so that with:
+
+		  (gdb) frame apply all -limit 10[TAB]
+
+		 we don't try to complete on command names.  */
+	      if (ov
+		  && !tracker.have_completions ()
+		  && **args == '\0'
+		  && *args > text && !isspace ((*args)[-1]))
+		{
+		  tracker.advance_custom_word_point_by
+		    (*args - text);
+		  return true;
+		}
+	    }
+	  else
+	    {
+	      tracker.advance_custom_word_point_by
+		(completion_info.word - text);
+
+	      /* If the command requires a delimiter, but we haven't
+		 seen one, then return true, so that the caller
+		 doesn't try to complete on whatever follows options,
+		 which for these commands should only be done if
+		 there's a delimiter.  */
+	      if (mode == PROCESS_OPTIONS_REQUIRE_DELIMITER
+		  && !have_delimiter)
+		{
+		  /* If we reached the end of the input string, then
+		     offer all options, since that's all the user can
+		     type (plus "--").  */
+		  if (completion_info.word[0] == '\0')
+		    complete_on_all_options (tracker, options_group);
+		  return true;
+		}
+	      else
+		return false;
+	    }
+
+	  if (tracker.have_completions ())
+	    {
+	      tracker.advance_custom_word_point_by
+		(completion_info.word - text);
+	      return true;
+	    }
+	}
+    }
+  else if (delimiter != nullptr)
+    {
+      tracker.advance_custom_word_point_by (delimiter - text);
+      *args = delimiter;
+      return false;
+    }
+
+  return false;
+}
+
+/* See cli-option.h.  */
+
+bool
+process_options (const char **args,
+		 process_options_mode mode,
+		 gdb::array_view<const option_def_group> options_group)
+{
+  if (*args == nullptr)
+    return false;
+
+  /* If ARGS starts with "-", look for a "--" sequence.  If one is
+     found, then interpret everything up until the "--" as
+     'gdb::option'-style command line options.  Otherwise, interpret
+     ARGS as possibly the command's operands.  */
+  bool have_delimiter = find_end_options_delimiter (*args) != nullptr;
+
+  if (mode == PROCESS_OPTIONS_REQUIRE_DELIMITER && !have_delimiter)
+    return false;
+
+  bool processed_any = false;
+
+  while (1)
+    {
+      *args = skip_spaces (*args);
+
+      auto ov = parse_option (options_group, mode, have_delimiter, args);
+      if (!ov)
+	{
+	  if (processed_any)
+	    return true;
+	  return false;
+	}
+
+      processed_any = true;
+
+      switch (ov->option.type)
+	{
+	case var_boolean:
+	  {
+	    bool value = ov->value.has_value () ? ov->value->boolean : true;
+	    *ov->option.var_address.boolean (ov->option, ov->ctx) = value;
+	  }
+	  break;
+	case var_uinteger:
+	  *ov->option.var_address.uinteger (ov->option, ov->ctx)
+	    = ov->value->uinteger;
+	  break;
+	case var_zuinteger_unlimited:
+	  *ov->option.var_address.integer (ov->option, ov->ctx)
+	    = ov->value->integer;
+	  break;
+	case var_enum:
+	  *ov->option.var_address.enumeration (ov->option, ov->ctx)
+	    = ov->value->enumeration;
+	  break;
+	default:
+	  gdb_assert_not_reached ("unhandled option type");
+	}
+    }
+}
+
+/* Helper for build_help.  Return a fragment of a help string showing
+   OPT's possible values.  Returns NULL if OPT doesn't take an
+   argument.  */
+
+static const char *
+get_val_type_str (const option_def &opt, std::string &buffer)
+{
+  if (!opt.have_argument)
+    return nullptr;
+
+  switch (opt.type)
+    {
+    case var_boolean:
+      return "[on|off]";
+    case var_uinteger:
+    case var_zuinteger_unlimited:
+      return "NUMBER|unlimited";
+    case var_enum:
+      {
+	buffer = "";
+	for (size_t i = 0; opt.enums[i] != nullptr; i++)
+	  {
+	    if (i != 0)
+	      buffer += "|";
+	    buffer += opt.enums[i];
+	  }
+	return buffer.c_str ();
+      }
+    default:
+      return nullptr;
+    }
+}
+
+/* Helper for build_help.  Appends an indented version of DOC into
+   HELP.  */
+
+static void
+append_indented_doc (const char *doc, std::string &help)
+{
+  const char *p = doc;
+  const char *n = strchr (p, '\n');
+
+  while (n != nullptr)
+    {
+      help += "    ";
+      help.append (p, n - p + 1);
+      p = n + 1;
+      n = strchr (p, '\n');
+    }
+  help += "    ";
+  help += p;
+  help += '\n';
+}
+
+/* Fill HELP with an auto-generated "help" string fragment for
+   OPTIONS.  */
+
+static void
+build_help_option (gdb::array_view<const option_def> options,
+		   std::string &help)
+{
+  std::string buffer;
+
+  for (const auto &o : options)
+    {
+      if (o.set_doc == nullptr)
+	continue;
+
+      help += "  -";
+      help += o.name;
+
+      const char *val_type_str = get_val_type_str (o, buffer);
+      if (val_type_str != nullptr)
+	{
+	  help += ' ';
+	  help += val_type_str;
+	}
+      help += "\n";
+      append_indented_doc (o.set_doc, help);
+      if (o.help_doc != nullptr)
+	append_indented_doc (o.help_doc, help);
+      help += '\n';
+    }
+}
+
+/* See cli-option.h.  */
+
+std::string
+build_help (const char *help_tmpl,
+	    gdb::array_view<const option_def_group> options_group)
+{
+  std::string help_str;
+
+  const char *p = strstr (help_tmpl, "%OPTIONS%");
+  help_str.assign (help_tmpl, p);
+
+  for (const auto &grp : options_group)
+    for (const auto &opt : grp.options)
+      build_help_option (opt, help_str);
+
+  p += strlen ("%OPTIONS%");
+  help_str.append (p);
+
+  return help_str;
+}
+
+/* See cli-option.h.  */
+
+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)
+{
+  for (const auto &option : options)
+    {
+      if (option.type == var_boolean)
+	{
+	  add_setshow_boolean_cmd (option.name, cmd_class,
+				   option.var_address.boolean (option, data),
+				   option.set_doc, option.show_doc,
+				   option.help_doc,
+				   nullptr, option.show_cmd_cb,
+				   set_list, show_list);
+	}
+      else if (option.type == var_uinteger)
+	{
+	  add_setshow_uinteger_cmd (option.name, cmd_class,
+				    option.var_address.uinteger (option, data),
+				    option.set_doc, option.show_doc,
+				    option.help_doc,
+				    nullptr, option.show_cmd_cb,
+				    set_list, show_list);
+	}
+      else if (option.type == var_zuinteger_unlimited)
+	{
+	  add_setshow_zuinteger_unlimited_cmd
+	    (option.name, cmd_class,
+	     option.var_address.integer (option, data),
+	     option.set_doc, option.show_doc,
+	     option.help_doc,
+	     nullptr, option.show_cmd_cb,
+	     set_list, show_list);
+	}
+      else if (option.type == var_enum)
+	{
+	  add_setshow_enum_cmd (option.name, cmd_class,
+				option.enums,
+				option.var_address.enumeration (option, data),
+				option.set_doc, option.show_doc,
+				option.help_doc,
+				nullptr, option.show_cmd_cb,
+				set_list, show_list);
+	}
+      else
+	gdb_assert_not_reached (_("option type not handled"));
+    }
+}
+
+} /* namespace option */
+} /* namespace gdb */
diff --git a/gdb/cli/cli-option.h b/gdb/cli/cli-option.h
new file mode 100644
index 00000000000..1bfbfce1ce5
--- /dev/null
+++ b/gdb/cli/cli-option.h
@@ -0,0 +1,335 @@ 
+/* CLI options framework, for GDB.
+
+   Copyright (C) 2017-2019 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef CLI_OPTION_H
+#define CLI_OPTION_H 1
+
+#include "common/gdb_optional.h"
+#include "common/array-view.h"
+#include "completer.h"
+#include <string>
+#include "command.h"
+
+namespace gdb {
+namespace option {
+
+/* A type-erased option definition.  The actual type of the option is
+   stored in the TYPE field.  Client code cannot define objects of
+   this type directly (the ctor is protected).  Instead, one of the
+   wrapper types below that extends this (boolean_option_def,
+   flag_option_def, uinteger_option_def, etc.) should be defined.  */
+struct option_def
+{
+  /* The ctor is protected because you're supposed to construct using
+     one of bool_option_def, etc. below.  */
+protected:
+  typedef void *(erased_get_var_address_ftype) ();
+
+  /* Construct an option.  NAME_ is the option's name.  VAR_TYPE_
+     defines the option's type.  ERASED_GET_VAR_ADDRESS_ is a pointer
+     to a function that returns the option's control variable.
+     SHOW_CMD_CB_ is a pointer to callback for the "show" command that
+     is installed for this option.  SET_DOC_, SHOW_DOC_, HELP_DOC_ are
+     used to create the option's "set/show" commands.  */
+  constexpr option_def (const char *name_,
+			var_types var_type_,
+			erased_get_var_address_ftype *erased_get_var_address_,
+			show_value_ftype *show_cmd_cb_,
+			const char *set_doc_,
+			const char *show_doc_,
+			const char *help_doc_)
+    : name (name_), type (var_type_),
+      erased_get_var_address (erased_get_var_address_),
+      var_address {},
+      show_cmd_cb (show_cmd_cb_),
+      set_doc (set_doc_), show_doc (show_doc_), help_doc (help_doc_)
+  {}
+
+public:
+  /* The option's name.  */
+  const char *name;
+
+  /* The option's type.  */
+  var_types type;
+
+  /* A function that gets the controlling variable's address, type
+     erased.  */
+  erased_get_var_address_ftype *erased_get_var_address;
+
+  /* Get the controlling variable's address.  Each type of variable
+     uses a different union member.  We do this instead of having a
+     single hook that return a "void *", for better type safety.  This
+     way, actual instances of concrete option_def types
+     (boolean_option_def, etc.) fail to compile if you pass in a
+     function with incorrect return type.  CTX here is the aggregate
+     object that groups the option variables from which the callback
+     returns the address of some member.  */
+  union
+    {
+      int *(*boolean) (const option_def &, void *ctx);
+      unsigned int *(*uinteger) (const option_def &, void *ctx);
+      int *(*integer) (const option_def &, void *ctx);
+      const char **(*enumeration) (const option_def &, void *ctx);
+    }
+  var_address;
+
+  /* Pointer to null terminated list of enumerated values (like argv).
+     Only used by var_enum options.  */
+  const char *const *enums = nullptr;
+
+  /* True if the option takes an argument.  */
+  bool have_argument = true;
+
+  /* The "show" callback to use in the associated "show" command.
+     E.g., "show print elements".  */
+  show_value_ftype *show_cmd_cb;
+
+  /* The set/show/help strings.  These are shown in both the help of
+     commands that use the option group this option belongs to (e.g.,
+     "help print"), and in the associated commands (e.g., "set/show
+     print elements", "help set print elements").  */
+  const char *set_doc;
+  const char *show_doc;
+  const char *help_doc;
+
+  /* Convenience method that returns THIS as an option_def.  Useful
+     when you're putting an option_def subclass in an option_def
+     array_view.  */
+  const option_def &def () const
+  {
+    return *this;
+  }
+};
+
+namespace detail
+{
+
+/* Get the address of the option's value, cast to the right type.
+   RetType is the restored type of the variable, and Context is the
+   restored type of the context pointer.  */
+template<typename RetType, typename Context>
+static inline RetType *
+get_var_address (const option_def &option, void *ctx)
+{
+  using unerased_ftype = RetType *(Context *);
+  unerased_ftype *fun = (unerased_ftype *) option.erased_get_var_address;
+  return fun ((Context *) ctx);
+}
+
+/* Convenience identity helper that just returns SELF.  */
+
+template<typename T>
+static T *
+return_self (T *self)
+{
+  return self;
+}
+
+} /* namespace detail */
+
+/* Follows the definitions of the option types that client code should
+   define.  Note that objects of these types are placed in option_def
+   arrays, by design, so they must not have data fields of their
+   own.  */
+
+/* A var_boolean command line option.  */
+
+template<typename Context>
+struct boolean_option_def : option_def
+{
+  boolean_option_def (const char *long_option_,
+		      int *(*get_var_address_cb_) (Context *),
+		      show_value_ftype *show_cmd_cb_,
+		      const char *set_doc_,
+		      const char *show_doc_ = nullptr,
+		      const char *help_doc_ = nullptr)
+    : option_def (long_option_, var_boolean,
+		  (erased_get_var_address_ftype *) get_var_address_cb_,
+		  show_cmd_cb_,
+		  set_doc_, show_doc_, help_doc_)
+  {
+    var_address.boolean = detail::get_var_address<int, Context>;
+  }
+};
+
+/* A flag command line option.  This is a var_boolean option under the
+   hood, but unlike boolean options, flag options don't take an on/off
+   argument.  */
+
+template<typename Context = int>
+struct flag_option_def : boolean_option_def<Context>
+{
+  flag_option_def (const char *long_option_,
+		     int *(*var_address_cb_) (Context *),
+		     const char *set_doc_,
+		     const char *help_doc_ = nullptr)
+    : boolean_option_def<Context> (long_option_,
+				   var_address_cb_,
+				   NULL,
+				   set_doc_, NULL, help_doc_)
+  {
+    this->have_argument = false;
+  }
+
+  flag_option_def (const char *long_option_,
+		     const char *set_doc_,
+		     const char *help_doc_ = nullptr)
+    : boolean_option_def<Context> (long_option_,
+				   gdb::option::detail::return_self,
+				   NULL,
+				   set_doc_, nullptr, help_doc_)
+  {
+    this->have_argument = false;
+  }
+};
+
+/* A var_uinteger command line option.  */
+
+template<typename Context>
+struct uinteger_option_def : option_def
+{
+  uinteger_option_def (const char *long_option_,
+		       unsigned int *(*get_var_address_cb_) (Context *),
+		       show_value_ftype *show_cmd_cb_,
+		       const char *set_doc_,
+		       const char *show_doc_ = nullptr,
+		       const char *help_doc_ = nullptr)
+    : option_def (long_option_, var_uinteger,
+		  (erased_get_var_address_ftype *) get_var_address_cb_,
+		  show_cmd_cb_,
+		  set_doc_, show_doc_, help_doc_)
+  {
+    var_address.uinteger = detail::get_var_address<unsigned int, Context>;
+  }
+};
+
+/* A var_zuinteger_unlimited command line option.  */
+
+template<typename Context>
+struct zuinteger_unlimited_option_def : option_def
+{
+  zuinteger_unlimited_option_def (const char *long_option_,
+				  int *(*get_var_address_cb_) (Context *),
+				  show_value_ftype *show_cmd_cb_,
+				  const char *set_doc_,
+				  const char *show_doc_ = nullptr,
+				  const char *help_doc_ = nullptr)
+    : option_def (long_option_, var_zuinteger_unlimited,
+		  (erased_get_var_address_ftype *) get_var_address_cb_,
+		  show_cmd_cb_,
+		  set_doc_, show_doc_, help_doc_)
+  {
+    var_address.integer = detail::get_var_address<int, Context>;
+  }
+};
+
+/* An var_enum command line option.  */
+
+template<typename Context>
+struct enum_option_def : option_def
+{
+  enum_option_def (const char *long_option_,
+		   const char *const *enumlist,
+		   const char **(*get_var_address_cb_) (Context *),
+		   show_value_ftype *show_cmd_cb_,
+		   const char *set_doc_,
+		   const char *show_doc_ = nullptr,
+		   const char *help_doc_ = nullptr)
+    : option_def (long_option_, var_enum,
+		  (erased_get_var_address_ftype *) get_var_address_cb_,
+		  show_cmd_cb_,
+		  set_doc_, show_doc_, help_doc_)
+  {
+    var_address.enumeration = detail::get_var_address<const char *, Context>;
+    this->enums = enumlist;
+  }
+};
+
+/* A group of options that all share the same context pointer to pass
+   to the options' get-current-value callbacks.  */
+struct option_def_group
+{
+  /* The list of options.  */
+  gdb::array_view<const option_def> options;
+
+  /* The context pointer to pass to the options' get-current-value
+     callbacks.  */
+  void *ctx;
+};
+
+/* Modes of operation for process_options.  */
+enum process_options_mode
+{
+  /* In this mode, options are only processed if we find a "--"
+     delimiter.  Throws an error if unknown options are found.  */
+  PROCESS_OPTIONS_REQUIRE_DELIMITER,
+
+  /* In this mode, a "--" delimiter is not required.  Throws an error
+     if unknown options are found, regardless of whether a delimiter
+     is present.  */
+  PROCESS_OPTIONS_UNKNOWN_IS_ERROR,
+
+  /* In this mode, a "--" delimiter is not required.  If an unknown
+     option is found, assume it is the command's argument/operand.  */
+  PROCESS_OPTIONS_UNKNOWN_IS_OPERAND,
+};
+
+/* Process ARGS, using OPTIONS_GROUP as valid options.  Returns true
+   if the string has been fully parsed and there are no operands to
+   handle by the caller.  Return false if options were parsed, and
+   *ARGS now points at the first operand.  */
+extern bool process_options
+  (const char **args,
+   process_options_mode mode,
+   gdb::array_view<const option_def_group> options_group);
+
+/* Complete ARGS on options listed by OPTIONS_GROUP.  Returns true if
+   the string has been fully parsed and there are no operands to
+   handle by the caller.  Return false if options were parsed, and
+   *ARGS now points at the first operand.  */
+extern bool complete_options
+  (completion_tracker &tracker,
+   const char **args,
+   process_options_mode mode,
+   gdb::array_view<const option_def_group> options_group);
+
+/* Complete on all options listed by OPTIONS_GROUP.  */
+extern void
+  complete_on_all_options (completion_tracker &tracker,
+			   gdb::array_view<const option_def_group> options_group);
+
+/* Return a string with the result of replacing %OPTIONS% in HELP_TMLP
+   with an auto-generated "help" string fragment for all the options
+   in OPTIONS_GROUP.  */
+extern std::string build_help
+  (const char *help_tmpl,
+   gdb::array_view<const option_def_group> options_group);
+
+/* 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);
+
+} /* namespace option */
+} /* namespace gdb */
+
+#endif /* CLI_OPTION_H */
diff --git a/gdb/cli/cli-setshow.c b/gdb/cli/cli-setshow.c
index 082bfe7f580..7de006da21f 100644
--- a/gdb/cli/cli-setshow.c
+++ b/gdb/cli/cli-setshow.c
@@ -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;
+  const char *p = skip_to_space (*arg);
+  size_t length = p - *arg;
 
-  length = strlen (arg);
+  /* Note that "o" is ambiguous.  */
 
-  while (arg[length - 1] == ' ' || arg[length - 1] == '\t')
-    length--;
+  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;
+}
 
-  /* Note that "o" is ambiguous.  */
+/* See cli-setshow.h.  */
 
-  if ((length == 2 && strncmp (arg, "on", length) == 0)
-      || strncmp (arg, "1", length) == 0
-      || strncmp (arg, "yes", length) == 0
-      || strncmp (arg, "enable", length) == 0)
+int
+parse_cli_boolean_value (const char *arg)
+{
+  if (!arg || !*arg)
     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;
-  else
+
+  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;
-
-	/* 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, ' ');
+	const char *end_arg = arg;
+	const char *match = parse_cli_var_enum (&end_arg, c->enums);
 
-	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 (_("Garbage after item \"%.*s\": \"%s\""),
 		 len, arg, after);
@@ -433,20 +492,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)
 	  {
diff --git a/gdb/cli/cli-setshow.h b/gdb/cli/cli-setshow.h
index e4d13c3510d..c00a0989145 100644
--- a/gdb/cli/cli-setshow.h
+++ b/gdb/cli/cli-setshow.h
@@ -23,6 +23,33 @@  struct cmd_list_element;
    Returns 1 for true, 0 for false, and -1 if invalid.  */
 extern int parse_cli_boolean_value (const char *arg);
 
+/* Same as above, but work with a pointer to pointer.  ARG is advanced
+   past a successfully parsed value.  */
+extern int parse_cli_boolean_value (const char **arg);
+
+/* Parse ARG, an option to a var_uinteger or var_zuinteger variable.
+   Either returns the parsed value on success or throws an error.  If
+   EXPRESSION is true, *ARG is parsed as an expression; otherwise, it
+   is parsed with get_ulongest.  It's not possible to parse the
+   integer as an expression when there may be valid input after the
+   integer, such as when parsing command options.  E.g., "print
+   -elements NUMBER -obj --".  In such case, parsing as an expression
+   would parse "-obj --" as part of the expression as well.  */
+extern unsigned int parse_cli_var_uinteger (var_types var_type,
+					    const char **arg,
+					    bool expression);
+
+/* Like parse_cli_var_uinteger, for var_zuinteger_unlimited.  */
+extern int parse_cli_var_zuinteger_unlimited (const char **arg,
+					      bool expression);
+
+/* Parse ARG, an option to a var_enum variable.  ENUM is a
+   null-terminated array of possible values. Either returns the parsed
+   value on success or throws an error.  ARG is advanced past the
+   parsed value.  */
+const char *parse_cli_var_enum (const char **args,
+				const char *const *enums);
+
 extern void do_set_command (const char *arg, int from_tty,
 			    struct cmd_list_element *c);
 extern void do_show_command (const char *arg, int from_tty,
diff --git a/gdb/cli/cli-utils.c b/gdb/cli/cli-utils.c
index 23296cee9c3..306b69e3d8f 100644
--- a/gdb/cli/cli-utils.c
+++ b/gdb/cli/cli-utils.c
@@ -27,6 +27,57 @@  static std::string extract_arg_maybe_quoted (const char **arg);
 
 /* See documentation in cli-utils.h.  */
 
+ULONGEST
+get_ulongest (const char **pp, int trailer)
+{
+  LONGEST retval = 0;	/* default */
+  const char *p = *pp;
+
+  if (*p == '$')
+    {
+      value *val = value_from_history_ref (p, &p);
+
+      if (val != NULL)	/* Value history reference */
+	{
+	  if (TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
+	    retval = value_as_long (val);
+	  else
+	    error (_("History value must have integer type."));
+	}
+      else	/* Convenience variable */
+	{
+	  /* Internal variable.  Make a copy of the name, so we can
+	     null-terminate it to pass to lookup_internalvar().  */
+	  const char *start = ++p;
+	  while (isalnum (*p) || *p == '_')
+	    p++;
+	  std::string varname (start, p - start);
+	  if (!get_internalvar_integer (lookup_internalvar (varname.c_str ()),
+				       &retval))
+	    error (_("Convenience variable $%s does not have integer value."),
+		   varname.c_str ());
+	}
+    }
+  else
+    {
+      retval = strtoulst (p, pp, 0);
+      if (p == *pp)
+	{
+	  /* There is no number here.  (e.g. "cond a == b").  */
+	  error (_("Expected integer at: %s"), p);
+	}
+      p = *pp;
+    }
+
+  if (!(isspace (*p) || *p == '\0' || *p == trailer))
+    error (_("Trailing junk at: %s"), p);
+  p = skip_spaces (p);
+  *pp = p;
+  return retval;
+}
+
+/* See documentation in cli-utils.h.  */
+
 int
 get_number_trailer (const char **pp, int trailer)
 {
diff --git a/gdb/cli/cli-utils.h b/gdb/cli/cli-utils.h
index 9425fb4c09d..41c23561d6f 100644
--- a/gdb/cli/cli-utils.h
+++ b/gdb/cli/cli-utils.h
@@ -39,6 +39,10 @@  extern int get_number (const char **);
 
 extern int get_number (char **);
 
+/* Like get_number_trailer, but works with ULONGEST, and throws on
+   error instead of returning 0.  */
+extern ULONGEST get_ulongest (const char **pp, int trailer = '\0');
+
 /* Extract from ARGS the arguments [-q] [-t TYPEREGEXP] [--] NAMEREGEXP.
 
    The caller is responsible to initialize *QUIET to false, *REGEXP
@@ -193,6 +197,14 @@  extern std::string extract_arg (const char **arg);
    argument.  */
 extern int check_for_argument (const char **str, const char *arg, int arg_len);
 
+/* Same as above, but ARG's length is computed.  */
+
+static inline int
+check_for_argument (const char **str, const char *arg)
+{
+  return check_for_argument (str, arg, strlen (arg));
+}
+
 /* Same, for non-const STR.  */
 
 static inline int
@@ -202,6 +214,12 @@  check_for_argument (char **str, const char *arg, int arg_len)
 			     arg, arg_len);
 }
 
+static inline int
+check_for_argument (char **str, const char *arg)
+{
+  return check_for_argument (str, arg, strlen (arg));
+}
+
 /* A helper function that looks for a set of flags at the start of a
    string.  The possible flags are given as a null terminated string.
    A flag in STR must either be at the end of the string,
diff --git a/gdb/maint-test-options.c b/gdb/maint-test-options.c
new file mode 100644
index 00000000000..e375522bcc7
--- /dev/null
+++ b/gdb/maint-test-options.c
@@ -0,0 +1,460 @@ 
+/* Maintenance commands for testing the options framework.
+
+   Copyright (C) 2019 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "defs.h"
+#include "gdbcmd.h"
+#include "cli/cli-option.h"
+
+/* This file defines a couple "maintenance test-options" subcommands
+   to exercise TAB-completion and option processing:
+
+    (gdb) maint test-options require-delimiter
+    (gdb) maint test-options unknown-is-error
+    (gdb) maint test-options unknown-is-operand
+
+   And a third one to help with TAB-completion testing.
+
+    (gdb) maint show test-options-completion-result
+
+   Each of the test-options subcommands exercise
+   gdb::option::process_options with a different enum
+   process_options_mode value.  Examples for command they model:
+
+   - "print" and "compile print", are like "require-delimiter",
+      because they accept random expressions as argument.
+
+   - "backtrace" and "frame/thread apply" are like
+     "unknown-is-operand", because "-" is a valid command.
+
+   - "compile file" and "compile code" are like "unknown-is-error".
+
+   These commands allow exercising all aspects of option processing
+   without having to pick some existing command.  That should be more
+   stable going forward than relying on an existing user command,
+   since if we picked say "print", that command or its options could
+   change in future, and then we'd be left with having to pick some
+   other command or option to exercise some non-command-specific
+   option processing detail.  Also, actual user commands have side
+   effects that we're not interested in when we're focusing on unit
+   testing the options machinery.  BTW, a maintenance command is used
+   as a sort of unit test driver instead of actual "maint selftest"
+   unit tests, since we need to go all the way via via including
+   readline, for proper testing of TAB completion.
+
+   These maintenance commands support options of all the different
+   available kinds of commands (boolean, enum, flag, uinteger):
+
+    (gdb) maint test-options require-delimiter -[TAB]
+    -bool      -enum      -flag      -uinteger   -xx1       -xx2
+
+    (gdb) maint test-options require-delimiter -bool o[TAB]
+    off  on
+    (gdb) maint test-options require-delimiter -enum [TAB]
+    xxx  yyy  zzz
+    (gdb) maint test-options require-delimiter -uinteger [TAB]
+    NUMBER     unlimited
+
+   '-xx1' and '-xx2' are flag options too.  They exist in order to
+   test ambiguous option names, like '-xx'.
+
+  Invoking the commands makes them print out the options parsed:
+
+   (gdb) maint test-options unknown-is-error -flag -enum yyy cmdarg
+   -flag 1 -xx1 0 -xx2 0 -bool 0 -enum yyy -uint 0 -zuint-unl 0 -- cmdarg
+
+   (gdb) maint test-options require-delimiter -flag -enum yyy cmdarg
+   -flag 0 -xx1 0 -xx2 0 -bool 0 -enum xxx -uint 0  -zuint-unl 0 -- -flag -enum yyy cmdarg
+   (gdb) maint test-options require-delimiter -flag -enum yyy cmdarg --
+   Unrecognized option at: cmdarg --
+   (gdb) maint test-options require-delimiter -flag -enum yyy -- cmdarg
+   -flag 1 -xx1 0 -xx2 0 -bool 0 -enum yyy -uint 0 -zuint-unl 0 -- cmdarg
+
+  The "maint show test-options-completion-result" command exists in
+  order to do something similar for completion:
+
+   (gdb) maint test-options unknown-is-error -flag -b 0 -enum yyy OPERAND[TAB]
+   (gdb) maint show test-options-completion-result
+   0 OPERAND
+
+   (gdb) maint test-options unknown-is-error -flag -b 0 -enum yyy[TAB]
+   (gdb) maint show test-options-completion-result
+   1
+
+   (gdb) maint test-options require-dash -unknown[TAB]
+   (gdb) maint show test-options-completion-result
+   1
+
+  Here, "1" means the completion function processed the whole input
+  line, and that the command shouldn't do anything with the arguments,
+  since there are no operands.  While "0" indicates that there are
+  operands after options.  The text after "0" is the operands.
+
+  This level of detail is particularly important because getting the
+  completion function's entry point to return back to the caller the
+  right pointer into the operand is quite tricky in several scenarios.  */
+
+/* Enum values for the "maintenance test-options" commands.  */
+const char test_options_enum_values_xxx[] = "xxx";
+const char test_options_enum_values_yyy[] = "yyy";
+const char test_options_enum_values_zzz[] = "zzz";
+static const char *const test_options_enum_values_choices[] =
+{
+  test_options_enum_values_xxx,
+  test_options_enum_values_yyy,
+  test_options_enum_values_zzz,
+  NULL
+};
+
+/* Option data for the "maintenance test-options" commands.  */
+
+struct test_options_opts
+{
+  int flag_opt = 0;
+  int xx1_opt = 0;
+  int xx2_opt = 0;
+  int boolean_opt = 0;
+  const char *enum_opt = test_options_enum_values_xxx;
+  unsigned int uint_opt = 0;
+  int zuint_unl_opt = 0;
+};
+
+/* Option definitions for the "maintenance test-options" commands.  */
+
+static const gdb::option::option_def test_options_option_defs[] = {
+
+  /* A flag option.  */
+  gdb::option::flag_option_def<test_options_opts> {
+    "flag",
+    [] (test_options_opts *opts) { return &opts->flag_opt; },
+    N_("A flag option."),
+  },
+
+  /* A couple flags with similar names, for "ambiguous option names"
+     testing.  */
+  gdb::option::flag_option_def<test_options_opts> {
+    "xx1",
+    [] (test_options_opts *opts) { return &opts->xx1_opt; },
+    N_("A flag option."),
+  },
+  gdb::option::flag_option_def<test_options_opts> {
+    "xx2",
+    [] (test_options_opts *opts) { return &opts->xx2_opt; },
+    N_("A flag option."),
+  },
+
+  /* A boolean option.  */
+  gdb::option::boolean_option_def<test_options_opts> {
+    "bool",
+    [] (test_options_opts *opts) { return &opts->boolean_opt; },
+    nullptr, /* show_cmd_cb */
+    N_("A boolean option."),
+  },
+
+  /* An enum option.  */
+  gdb::option::enum_option_def<test_options_opts> {
+    "enum",
+    test_options_enum_values_choices,
+    [] (test_options_opts *opts) { return &opts->enum_opt; },
+    nullptr, /* show_cmd_cb */
+    N_("An enum option."),
+  },
+
+  /* A uinteger option.  */
+  gdb::option::uinteger_option_def<test_options_opts> {
+    "uinteger",
+    [] (test_options_opts *opts) { return &opts->uint_opt; },
+    nullptr, /* show_cmd_cb */
+    N_("A uinteger option."),
+    nullptr, /* show_doc */
+    N_("A help doc that spawns\nmultiple lines."),
+  },
+
+  /* A zuinteger_unlimited option.  */
+  gdb::option::zuinteger_unlimited_option_def<test_options_opts> {
+    "zuinteger-unlimited",
+    [] (test_options_opts *opts) { return &opts->zuint_unl_opt; },
+    nullptr, /* show_cmd_cb */
+    N_("A zuinteger-unlimited option."),
+    nullptr, /* show_doc */
+    nullptr, /* help_doc */
+  },
+};
+
+/* Create an option_def_group for the test_options_opts options, with
+   OPTS as context.  */
+
+static inline gdb::option::option_def_group
+make_test_options_options_def_group (test_options_opts *opts)
+{
+  return {{test_options_option_defs}, opts};
+}
+
+/* Implementation of the "maintenance test-options
+   require-delimiter/unknown-is-error/unknown-is-operand" commands.
+   Each of the commands maps to a different enum process_options_mode
+   enumerator.  The test strategy is simply processing the options in
+   a number of scenarios, and printing back the parsed result.  */
+
+static void
+maintenance_test_options_command_mode (const char *args,
+				       gdb::option::process_options_mode mode)
+{
+  test_options_opts opts;
+
+  gdb::option::process_options (&args, mode,
+				make_test_options_options_def_group (&opts));
+
+  if (args == nullptr)
+    args = "";
+  else
+    args = skip_spaces (args);
+
+  printf_unfiltered (_("-flag %d -xx1 %d -xx2 %d -bool %d "
+		       "-enum %s -uint %s -zuint-unl %s -- %s\n"),
+		     opts.flag_opt,
+		     opts.xx1_opt,
+		     opts.xx2_opt,
+		     opts.boolean_opt,
+		     opts.enum_opt,
+		     (opts.uint_opt == UINT_MAX
+		      ? "unlimited"
+		      : pulongest (opts.uint_opt)),
+		     (opts.zuint_unl_opt == -1
+		      ? "unlimited"
+		      : plongest (opts.zuint_unl_opt)),
+		     args);
+}
+
+/* Variables used by the "maintenance show
+   test-options-completion-result" command.  These variables are
+   stored by the completer of the "maint test-options"
+   subcommands.  */
+
+/* The result of gdb::option::complete_options.  */
+static int maintenance_test_options_command_completion_result;
+/* The text at the word point after gdb::option::complete_options
+   returns.  */
+static std::string maintenance_test_options_command_completion_text;
+
+/* The "maintenance show test-options-completion-result" command.  */
+
+static void
+maintenance_show_test_options_completion_result
+  (struct ui_file *file, int from_tty,
+   struct cmd_list_element *c, const char *value)
+{
+  if (maintenance_test_options_command_completion_result)
+    fprintf_filtered (file, "1\n");
+  else
+    fprintf_filtered
+      (file, _("0 %s\n"),
+       maintenance_test_options_command_completion_text.c_str ());
+}
+
+/* Implementation of completer for the "maintenance test-options
+   require-delimiter/unknown-is-error/unknown-is-operand" commands.
+   Each of the commands maps to a different enum process_options_mode
+   enumerator.  */
+
+static void
+maintenance_test_options_completer_mode (completion_tracker &tracker,
+					 const char *text,
+					 gdb::option::process_options_mode mode)
+{
+  try
+    {
+      maintenance_test_options_command_completion_result
+	= gdb::option::complete_options
+	   (tracker, &text, mode,
+	    make_test_options_options_def_group (nullptr));
+      maintenance_test_options_command_completion_text = text;
+    }
+  catch (const gdb_exception_error &ex)
+    {
+      maintenance_test_options_command_completion_result = 1;
+      throw;
+    }
+}
+
+/* Implementation of the "maintenance test-options require-delimiter"
+   command.  */
+
+static void
+maintenance_test_options_require_delimiter_command (const char *args,
+						    int from_tty)
+{
+  maintenance_test_options_command_mode
+    (args, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER);
+}
+
+/* Implementation of the "maintenance test-options
+   unknown-is-error" command.  */
+
+static void
+maintenance_test_options_unknown_is_error_command (const char *args,
+						   int from_tty)
+{
+  maintenance_test_options_command_mode
+    (args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR);
+}
+
+/* Implementation of the "maintenance test-options
+   unknown-is-operand" command.  */
+
+static void
+maintenance_test_options_unknown_is_operand_command (const char *args,
+						     int from_tty)
+{
+  maintenance_test_options_command_mode
+    (args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND);
+}
+
+/* Completer for the "maintenance test-options require-delimiter"
+   command.  */
+
+static void
+maintenance_test_options_require_delimiter_command_completer
+  (cmd_list_element *ignore, completion_tracker &tracker,
+   const char *text, const char *word)
+{
+  maintenance_test_options_completer_mode
+    (tracker, text, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER);
+}
+
+/* Completer for the "maintenance test-options unknown-is-error"
+   command.  */
+
+static void
+maintenance_test_options_unknown_is_error_command_completer
+  (cmd_list_element *ignore, completion_tracker &tracker,
+   const char *text, const char *word)
+{
+  maintenance_test_options_completer_mode
+    (tracker, text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR);
+}
+
+/* Completer for the "maintenance test-options unknown-is-operand"
+   command.  */
+
+static void
+maintenance_test_options_unknown_is_operand_command_completer
+  (cmd_list_element *ignore, completion_tracker &tracker,
+   const char *text, const char *word)
+{
+  maintenance_test_options_completer_mode
+    (tracker, text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND);
+}
+
+/* Command list for maint test-options.  */
+struct cmd_list_element *maintenance_test_options_list;
+
+/* The "maintenance test-options" prefix command.  */
+
+static void
+maintenance_test_options_command (const char *arg, int from_tty)
+{
+  printf_unfiltered
+    (_("\"maintenance test-options\" must be followed "
+       "by the name of a subcommand.\n"));
+  help_list (maintenance_test_options_list, "maintenance test-options ",
+	     all_commands, gdb_stdout);
+}
+
+
+void
+_initialize_maint_test_options ()
+{
+  cmd_list_element *cmd;
+
+  add_prefix_cmd ("test-options", no_class, maintenance_test_options_command,
+		  _("\
+Generic command for testing the options infrastructure."),
+		  &maintenance_test_options_list,
+		  "maintenance test-options ", 0,
+		  &maintenancelist);
+
+  const auto def_group = make_test_options_options_def_group (nullptr);
+
+  static const std::string help_require_delim_str
+    = gdb::option::build_help (_("\
+Command used for testing options processing.\n\
+Usage: maint test-options require-delimiter [[OPTION]... --] [OPERAND]...\n\
+\n\
+Options:\n\
+\n\
+%OPTIONS%\n\
+If you specify any command option, you must use a double dash (\"--\")\n\
+to mark the end of option processing."),
+			       def_group);
+
+  static const std::string help_unknown_is_error_str
+    = gdb::option::build_help (_("\
+Command used for testing options processing.\n\
+Usage: maint test-options unknown-is-error [OPTION]... [OPERAND]...\n\
+\n\
+Options:\n\
+\n\
+%OPTIONS%"),
+			       def_group);
+
+  static const std::string help_unknown_is_operand_str
+    = gdb::option::build_help (_("\
+Command used for testing options processing.\n\
+Usage: maint test-options unknown-is-operand [OPTION]... [OPERAND]...\n\
+\n\
+Options:\n\
+\n\
+%OPTIONS%"),
+			       def_group);
+
+  cmd = add_cmd ("require-delimiter", class_maintenance,
+		 maintenance_test_options_require_delimiter_command,
+		 help_require_delim_str.c_str (),
+		 &maintenance_test_options_list);
+  set_cmd_completer_handle_brkchars
+    (cmd, maintenance_test_options_require_delimiter_command_completer);
+
+  cmd = add_cmd ("unknown-is-error", class_maintenance,
+		 maintenance_test_options_unknown_is_error_command,
+		 help_unknown_is_error_str.c_str (),
+		 &maintenance_test_options_list);
+  set_cmd_completer_handle_brkchars
+    (cmd, maintenance_test_options_unknown_is_error_command_completer);
+
+  cmd = add_cmd ("unknown-is-operand", class_maintenance,
+		 maintenance_test_options_unknown_is_operand_command,
+		 help_unknown_is_operand_str.c_str (),
+		 &maintenance_test_options_list);
+  set_cmd_completer_handle_brkchars
+    (cmd, maintenance_test_options_unknown_is_operand_command_completer);
+
+  add_setshow_zinteger_cmd ("test-options-completion-result", class_maintenance,
+			    &maintenance_test_options_command_completion_result,
+			    _("\
+Set maintenance test-options completion result."), _("\
+Show maintenance test-options completion result."), _("\
+Show the results of completing\n\
+\"maint test-options require-delimiter\",\n\
+\"maint test-options unknown-is-error\", or\n\
+\"maint test-options unknown-is-operand\"."),
+			    NULL,
+			    maintenance_show_test_options_completion_result,
+			    &maintenance_set_cmdlist,
+			    &maintenance_show_cmdlist);
+}
diff --git a/gdb/testsuite/gdb.base/options.c b/gdb/testsuite/gdb.base/options.c
new file mode 100644
index 00000000000..fd19922b54e
--- /dev/null
+++ b/gdb/testsuite/gdb.base/options.c
@@ -0,0 +1,33 @@ 
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2019 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+int xxx1= 123;
+
+struct S
+{
+  int a;
+  int b;
+  int c;
+};
+
+struct S g_s = {1, 2, 3};
+
+int
+main ()
+{
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.base/options.exp b/gdb/testsuite/gdb.base/options.exp
new file mode 100644
index 00000000000..1891176dc1d
--- /dev/null
+++ b/gdb/testsuite/gdb.base/options.exp
@@ -0,0 +1,554 @@ 
+# This testcase is part of GDB, the GNU debugger.
+
+# Copyright 2019 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Test the gdb::option framework.
+
+# The test uses the "maintenance test-options" subcommands to exercise
+# TAB-completion and option processing.
+
+load_lib completion-support.exp
+
+clean_restart
+
+if { ![readline_is_used] } {
+    untested "no tab completion support without readline"
+    return -1
+}
+
+# Check the completion result, as returned by the "maintenance show
+# test-options-completion-result" command.  TEST is used as test name.
+proc check_completion_result {expected test} {
+    gdb_test "maintenance show test-options-completion-result" \
+	"$expected" \
+	"$test: res=$expected"
+}
+
+# Like test_gdb_complete_unique, but the expected output is expected
+# to be the input line.  I.e., the line is already complete.  We're
+# just checking whether GDB recognizes the option and auto-appends a
+# space.
+proc test_completer_recognizes {res input_line} {
+    set expected_re [string_to_regexp $input_line]
+    test_gdb_complete_unique $input_line $expected_re
+    check_completion_result $res $input_line
+}
+
+# Wrapper around test_gdb_complete_multiple that also checks the
+# completion result is RES.
+proc res_test_gdb_complete_multiple {res cmd_prefix completion_word args} {
+    test_gdb_complete_multiple $cmd_prefix $completion_word {*}$args
+    check_completion_result $res "$cmd_prefix$completion_word"
+}
+
+# Wrapper around test_gdb_complete_none that also checks the
+# completion result is RES.
+proc res_test_gdb_complete_none { res input_line } {
+    test_gdb_complete_none $input_line
+    check_completion_result $res "$input_line"
+}
+
+# Wrapper around test_gdb_complete_unique that also checks the
+# completion result is RES.
+proc res_test_gdb_complete_unique { res input_line args} {
+    test_gdb_complete_unique $input_line {*}$args
+    check_completion_result $res "$input_line"
+}
+
+# Make a full command name from VARIANT.  VARIANT is either
+# "require-delimiter", "unknown-is-error" or "unknown-is-operand".
+proc make_cmd {variant} {
+    return "maint test-options $variant"
+}
+
+# Return a string for the expected result of running "maint
+# test-options xxx", with no flag/option set.  OPERAND is the expected
+# operand.
+proc expect_none {operand} {
+    return "-flag 0 -xx1 0 -xx2 0 -bool 0 -enum xxx -uint 0 -zuint-unl 0 -- $operand"
+}
+
+# Return a string for the expected result of running "maint
+# test-options xxx", with -flag set.  OPERAND is the expected operand.
+proc expect_flag {operand} {
+    return "-flag 1 -xx1 0 -xx2 0 -bool 0 -enum xxx -uint 0 -zuint-unl 0 -- $operand"
+}
+
+# Return a string for the expected result of running "maint
+# test-options xxx", with -bool set.  OPERAND is the expected operand.
+proc expect_bool {operand} {
+    return "-flag 0 -xx1 0 -xx2 0 -bool 1 -enum xxx -uint 0 -zuint-unl 0 -- $operand"
+}
+
+# Return a string for the expected result of running "maint
+# test-options xxx", with one of the integer options set to $VAL.
+# OPTION determines which option to expect set.  OPERAND is the
+# expected operand.
+proc expect_integer {option val operand} {
+    if {$option == "uinteger"} {
+	return "-flag 0 -xx1 0 -xx2 0 -bool 0 -enum xxx -uint $val -zuint-unl 0 -- $operand"
+    } elseif {$option == "zuinteger-unlimited"} {
+	return "-flag 0 -xx1 0 -xx2 0 -bool 0 -enum xxx -uint 0 -zuint-unl $val -- $operand"
+    } else {
+	error "unsupported option: $option"
+    }
+}
+
+set all_options {
+    "-bool"
+    "-enum"
+    "-flag"
+    "-uinteger"
+    "-xx1"
+    "-xx2"
+    "-zuinteger-unlimited"
+}
+
+# Miscellaneous tests.
+proc_with_prefix test-misc {variant} {
+    global all_options
+
+    set cmd [make_cmd $variant]
+
+    # Call test command with no arguments at all.
+    gdb_test "$cmd" [expect_none ""]
+
+    # Now with a single dash.
+    if {$variant == "require-delimiter"} {
+	gdb_test "$cmd -" [expect_none "-"]
+    } else {
+	gdb_test "$cmd -" "Ambiguous option at: -"
+    }
+
+    # Completing at "-" should list all options.
+    res_test_gdb_complete_multiple "1" "$cmd " "-" "" $all_options
+
+    # Now with a double dash.
+    gdb_test "$cmd --" [expect_none ""]
+
+    # "--" is recognized by options completer, gdb auto-appends a
+    # space.
+    test_completer_recognizes 1 "$cmd --"
+
+    # Now with a double dash, plus a dash as operand.
+    gdb_test "$cmd -- -" [expect_none "-"]
+    res_test_gdb_complete_none "0 -" "$cmd -- -"
+
+    # Completing an unambiguous option just appends an empty space.
+    test_completer_recognizes 1 "$cmd -flag"
+
+    # Try running an ambiguous option.
+    if {$variant == "require-delimiter"} {
+	gdb_test "$cmd -xx" [expect_none "-xx"]
+    } else {
+	gdb_test "$cmd -xx" "Ambiguous option at: -xx"
+    }
+
+    # Check that options are not case insensitive.
+    gdb_test "$cmd -flag --" [expect_flag ""]
+
+    # Check how the different modes behave on unknown option, with a
+    # delimiter.
+    gdb_test "$cmd -FLAG --" \
+	"Unrecognized option at: -FLAG --"
+
+    # Check how the different modes behave on unknown option, without
+    # a delimiter.
+    if {$variant == "unknown-is-error"} {
+	gdb_test "$cmd -FLAG" \
+	    "Unrecognized option at: -FLAG"
+    } else {
+	gdb_test "$cmd -FLAG" [expect_none "-FLAG"]
+    }
+
+    # Test parsing stops at a negative integer.
+    gdb_test "$cmd -1 --" \
+	"Unrecognized option at: -1 --"
+    gdb_test "$cmd -2 --" \
+	"Unrecognized option at: -2 --"
+}
+
+# Flag option tests.
+proc_with_prefix test-flag {variant} {
+    global all_options
+
+    set cmd [make_cmd $variant]
+
+    # Completing a flag just appends a space.
+    test_completer_recognizes 1 "$cmd -flag"
+
+    # Add a dash, and all options should be shown.
+    test_gdb_complete_multiple "$cmd  -flag " "-" "" $all_options
+
+    # Basic smoke tests of accepted / not accepted values.
+
+    # Check all the different variants a bool option may be specified.
+    if {$variant == "require-delimiter"} {
+	gdb_test "$cmd -flag 999" [expect_none "-flag 999"]
+    } else {
+	gdb_test "$cmd -flag 999" [expect_flag "999"]
+    }
+    gdb_test "$cmd -flag -- 999" [expect_flag "999"]
+
+    # If the "--" separator is present, then GDB errors out if the
+    # flag option is passed some value -- check that too.
+    gdb_test "$cmd -flag xxx 999 --" "Unrecognized option at: xxx 999 --"
+    gdb_test "$cmd -flag o 999 --" "Unrecognized option at: o 999 --"
+    gdb_test "$cmd -flag 1 999 --" "Unrecognized option at: 1 999 --"
+
+    # Extract twice the same flag, separated by one space.
+    gdb_test "$cmd -flag -flag -- non flags args" \
+	[expect_flag "non flags args"]
+
+    # Extract twice the same flag, separated by one space.
+    gdb_test "$cmd -xx1     -xx2 -xx1  -xx2 -xx1    -- non flags args" \
+	"-flag 0 -xx1 1 -xx2 1 -bool 0 -enum xxx -uint 0 -zuint-unl 0 -- non flags args"
+
+    # Extract 2 known flags in front of unknown flags.
+    gdb_test "$cmd -xx1 -xx2 -a -b -c -xx1 --" \
+	"Unrecognized option at: -a -b -c -xx1 --"
+
+    # Check that combined flags are not recognised.
+    gdb_test "$cmd -xx1 -xx1xx2 -xx1 --" \
+	"Unrecognized option at: -xx1xx2 -xx1 --"
+
+    # Make sure the completer don't confuse a flag option with a
+    # boolean option.  Specifically, "o" should not complete to
+    # "on/off".
+
+    if {$variant == "require-delimiter"} {
+	res_test_gdb_complete_none "1" "$cmd -flag o"
+
+	gdb_test "$cmd -flag o" [expect_none "-flag o"]
+    } else {
+	res_test_gdb_complete_none "0 o" "$cmd -flag o"
+
+	gdb_test "$cmd -flag o" [expect_flag "o"]
+    }
+}
+
+# Boolean option tests.
+proc_with_prefix test-boolean {variant} {
+    global all_options
+
+    set cmd [make_cmd $variant]
+
+    # Boolean option's values are optional -- "on" is implied.  Check
+    # that:
+    #
+    # - For require-delimiter commands, completing after a boolean
+    #   option lists all other options, plus "on/off".  This is
+    #   because operands won't be processed until we see a "--"
+    #   delimiter.
+    #
+    # - For !require-delimiter commands, completing after a boolean
+    #   option completes as an operand, since that will tend to be
+    #   more common than typing "on/off".
+    #   E.g., "frame apply all -past-main COMMAND".
+
+    if {$variant == "require-delimiter"} {
+	res_test_gdb_complete_multiple 1 "$cmd -bool " "" "" {
+	    "-bool"
+	    "-enum"
+	    "-flag"
+	    "-uinteger"
+	    "-xx1"
+	    "-xx2"
+	    "-zuinteger-unlimited"
+	    "off"
+	    "on"
+	}
+    } else {
+	res_test_gdb_complete_none "0 " "$cmd -bool "
+    }
+
+    # Add another dash, and "on/off" are no longer offered:
+    res_test_gdb_complete_multiple 1 "$cmd -bool " "-" ""  $all_options
+
+    # Basic smoke tests of accepted / not accepted values.
+
+    # The command accepts all of "1/0/enable/disable/yes/no" too, even
+    # though like the "set" command, we don't offer those as
+    # completion candidates if you complete right after the boolean
+    # command's name, like:
+    #
+    #  (gdb) maint test-options require-delimiter -bool [TAB]
+    #  off        on
+    #
+    # However, the completer does recognize them if you start typing
+    # the boolean value.
+    foreach value {"0" "1"} {
+	test_completer_recognizes 1 "$cmd -bool $value"
+    }
+    foreach value {"of" "off"} {
+	res_test_gdb_complete_unique 1 \
+	    "$cmd -bool $value" \
+	    "$cmd -bool off"
+    }
+    foreach value {"y" "ye" "yes"} {
+	res_test_gdb_complete_unique 1 \
+	    "$cmd -bool $value" \
+	    "$cmd -bool yes"
+    }
+    foreach value {"n" "no"} {
+	res_test_gdb_complete_unique 1 \
+	    "$cmd -bool $value" \
+	    "$cmd -bool no"
+    }
+    foreach value {
+	"e"
+	"en"
+	"ena"
+	"enab"
+	"enabl"
+	"enable"
+    } {
+	res_test_gdb_complete_unique 1 \
+	    "$cmd -bool $value" \
+	    "$cmd -bool enable"
+    }
+    foreach value {
+	"d"
+	"di"
+	"dis"
+	"disa"
+	"disab"
+	"disabl"
+	"disable"
+    } {
+	res_test_gdb_complete_unique 1 \
+	    "$cmd -bool $value" \
+	    "$cmd -bool disable"
+    }
+
+    if {$variant == "require-delimiter"} {
+	res_test_gdb_complete_none "1" "$cmd -bool xxx"
+    } else {
+	res_test_gdb_complete_none "0 xxx" "$cmd -bool xxx"
+    }
+
+    # The command accepts abbreviations of "enable/disable/yes/no",
+    # even though we don't offer those for completion.
+    foreach value {
+	"1"
+	"y" "ye" "yes"
+	"e"
+	"en"
+	"ena"
+	"enab"
+	"enabl"
+	"enable"} {
+	gdb_test "$cmd -bool $value --" [expect_bool ""]
+    }
+    foreach value {
+	"0"
+	"of" "off"
+	"n" "no"
+	"d"
+	"di"
+	"dis"
+	"disa"
+	"disab"
+	"disabl"
+	"disable"} {
+	gdb_test "$cmd -bool $value --" [expect_none ""]
+    }
+
+    if {$variant == "require-delimiter"} {
+	gdb_test "$cmd -bool 999" [expect_none "-bool 999"]
+    } else {
+	gdb_test "$cmd -bool 999" [expect_bool "999"]
+    }
+    gdb_test "$cmd -bool -- 999" [expect_bool "999"]
+
+    # Since "on" is implied after a boolean option, for
+    # !require-delimiter commands, anything that is not
+    # yes/no/1/0/on/off/enable/disable should be considered as the raw
+    # input after the last option.  Also check "o", which might look
+    # like "on" or "off", but it's treated the same.
+
+    foreach arg {"xxx" "o"} {
+	if {$variant == "require-delimiter"} {
+	    gdb_test "$cmd -bool $arg" [expect_none "-bool $arg"]
+	} else {
+	    gdb_test "$cmd -bool $arg" [expect_bool "$arg"]
+	}
+    }
+    # Also try -1.  "unknown-is-error" commands error out saying that
+    # that's not a valid option.
+    if {$variant == "require-delimiter"} {
+	gdb_test "$cmd -bool -1" \
+	     [expect_none "-bool -1"]
+    } elseif {$variant == "unknown-is-error"} {
+	gdb_test "$cmd -bool -1" \
+	    "Unrecognized option at: -1"
+    } else {
+	gdb_test "$cmd -bool -1" [expect_bool "-1"]
+    }
+
+    # OTOH, if the "--" separator is present, then GDB errors out if
+    # the boolean option is passed an invalid value -- check that too.
+    gdb_test "$cmd -bool -1 999 --" \
+	"Unrecognized option at: -1 999 --"
+    gdb_test "$cmd -bool xxx 999 --" \
+	"Value given for `-bool' is not a boolean: xxx"
+    gdb_test "$cmd -bool o 999 --" \
+	"Value given for `-bool' is not a boolean: o"
+
+    # Completing after a boolean option + "o" does list "on/off",
+    # though.
+    if {$variant == "require-delimiter"} {
+	res_test_gdb_complete_multiple 1 "$cmd -bool " "o" "" {
+	    "off"
+	    "on"
+	}
+    } else {
+	res_test_gdb_complete_multiple "0 o" "$cmd -bool " "o" "" {
+	    "off"
+	    "on"
+	}
+    }
+}
+
+# Uinteger option tests.  OPTION is which integer option we're
+# testing.  Can be "uinteger" or "zuinteger-unlimited".
+proc_with_prefix test-uinteger {variant option} {
+    global all_options
+
+    set cmd "[make_cmd $variant] -$option"
+
+    # Test completing a uinteger option:
+    res_test_gdb_complete_multiple 1 "$cmd " "" "" {
+	"NUMBER"
+	"unlimited"
+    }
+
+    # NUMBER above is just a placeholder, make sure we don't complete
+    # it as a valid option.
+    res_test_gdb_complete_none 1 "$cmd NU"
+
+    # "unlimited" is valid though.
+    res_test_gdb_complete_unique 1 \
+	"$cmd u" \
+	"$cmd unlimited"
+
+    # Basic smoke test of accepted / not accepted values.
+    gdb_test "$cmd 1 -- 999" [expect_integer $option "1" "999"]
+    gdb_test "$cmd unlimited -- 999" \
+	[expect_integer $option "unlimited" "999"]
+    if {$option == "zuinteger-unlimited"} {
+	gdb_test "$cmd -1 --" [expect_integer $option "unlimited" ""]
+	gdb_test "$cmd 0 --" [expect_integer $option "0" ""]
+    } else {
+	gdb_test "$cmd -1 --" "integer -1 out of range"
+	gdb_test "$cmd 0 --" [expect_integer $option "unlimited" ""]
+    }
+    gdb_test "$cmd xxx --" \
+	"Expected integer at: xxx --"
+    gdb_test "$cmd unlimitedx --" \
+	"Expected integer at: unlimitedx --"
+
+    # Don't offer completions until we're past the
+    # -uinteger/-zuinteger-unlimited argument.
+    res_test_gdb_complete_none 1 "$cmd 1"
+
+    # A number of invalid values.
+    foreach value {"x" "x " "1a" "1a " "1-" "1- " "unlimitedx"} {
+	res_test_gdb_complete_none 1 "$cmd $value"
+    }
+
+    # Try "-1".
+    if {$option == "uinteger"} {
+	# -1 is invalid uinteger.
+	foreach value {"-1" "-1 "} {
+	    res_test_gdb_complete_none 1 "$cmd $value"
+	}
+    } else {
+	# -1 is valid for zuinteger-unlimited.
+	res_test_gdb_complete_none 1 "$cmd -1"
+	if {$variant == "require-delimiter"} {
+	    res_test_gdb_complete_multiple 1 "$cmd -1 " "" "-" $all_options
+	} else {
+	    res_test_gdb_complete_none "0 " "$cmd -1 "
+	}
+    }
+
+    # Check that after a fully parsed option:
+    #
+    #  - for require-delimiter commands, completion offers all
+    #    options.
+    #
+    #  - for !require-delimiter commands, completion offers nothing
+    #    and returns false.
+    if {$variant == "require-delimiter"} {
+	res_test_gdb_complete_multiple 1 "$cmd 1 " "" "-" $all_options
+    } else {
+	res_test_gdb_complete_none "0 " "$cmd 1 "
+    }
+
+    # Test completing non-option arguments after "-uinteger 1 ".
+    foreach operand {"x" "x " "1a" "1a " "1-" "1- "} {
+	if {$variant == "require-delimiter"} {
+	    res_test_gdb_complete_none 1 "$cmd 1 $operand"
+	} else {
+	    res_test_gdb_complete_none "0 $operand" "$cmd 1 $operand"
+	}
+    }
+    # These look like options, but they aren't.
+    foreach operand {"-1" "-1 "} {
+	if {$variant == "unknown-is-operand"} {
+	    res_test_gdb_complete_none "0 $operand" "$cmd 1 $operand"
+	} else {
+	    res_test_gdb_complete_none 1 "$cmd 1 $operand"
+	}
+    }
+}
+
+# Enum option tests.
+proc_with_prefix test-enum {variant} {
+    set cmd [make_cmd $variant]
+
+    res_test_gdb_complete_multiple 1 "$cmd -enum " "" "" {
+	"xxx"
+	"yyy"
+	"zzz"
+    }
+
+    # Check that "-" where a value is expected does not show the
+    # command's options.  I.e., an enum's value is not optional.
+    # Check both completion and running the command.
+    res_test_gdb_complete_none 1 "$cmd -enum -"
+    gdb_test "$cmd -enum --"\
+	"Requires an argument. Valid arguments are xxx, yyy, zzz\\."
+
+    # Try passing an undefined item to an enum option.
+    gdb_test "$cmd -enum www --" "Undefined item: \"www\"."
+}
+
+# Run the options framework tests first.
+foreach_with_prefix cmd {
+    "require-delimiter"
+    "unknown-is-error"
+    "unknown-is-operand"
+} {
+    test-misc $cmd
+    test-flag $cmd
+    test-boolean $cmd
+    foreach subcmd {"uinteger" "zuinteger-unlimited" } {
+	test-uinteger $cmd $subcmd
+    }
+    test-enum $cmd
+}