1 /* CLI options framework, for GDB.
3 Copyright (C) 2017-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "cli/cli-option.h"
22 #include "cli/cli-decode.h"
23 #include "cli/cli-utils.h"
24 #include "cli/cli-setshow.h"
31 /* An option's value. Which field is active depends on the option's
35 /* For var_boolean options. */
38 /* For var_uinteger options. */
39 unsigned int uinteger
;
41 /* For var_zuinteger_unlimited options. */
44 /* For var_enum options. */
45 const char *enumeration
;
47 /* For var_string options. This is malloc-allocated. */
51 /* Holds an options definition and its value. */
52 struct option_def_and_value
54 /* The option definition. */
55 const option_def
&option
;
60 /* The option's value, if any. */
61 gdb::optional
<option_value
> value
;
64 option_def_and_value (const option_def
&option_
, void *ctx_
,
65 gdb::optional
<option_value
> &&value_
= {})
68 value (std::move (value_
))
70 clear_value (option_
, value_
);
73 /* Move constructor. Need this because for some types the values
74 are allocated on the heap. */
75 option_def_and_value (option_def_and_value
&&rval
)
76 : option (rval
.option
),
78 value (std::move (rval
.value
))
80 clear_value (rval
.option
, rval
.value
);
83 DISABLE_COPY_AND_ASSIGN (option_def_and_value
);
85 ~option_def_and_value ()
87 if (value
.has_value ())
89 if (option
.type
== var_string
)
90 xfree (value
->string
);
96 /* Clear the option_value, without releasing it. This is used after
97 the value has been moved to some other option_def_and_value
98 instance. This is needed because for some types the value is
99 allocated on the heap, so we must clear the pointer in the
100 source, to avoid a double free. */
101 static void clear_value (const option_def
&option
,
102 gdb::optional
<option_value
> &value
)
104 if (value
.has_value ())
106 if (option
.type
== var_string
)
107 value
->string
= nullptr;
112 static void save_option_value_in_ctx (gdb::optional
<option_def_and_value
> &ov
);
114 /* Info passed around when handling completion. */
115 struct parse_option_completion_info
117 /* The completion word. */
121 completion_tracker
&tracker
;
124 /* If ARGS starts with "-", look for a "--" delimiter. If one is
125 found, then interpret everything up until the "--" as command line
126 options. Otherwise, interpret unknown input as the beginning of
127 the command's operands. */
130 find_end_options_delimiter (const char *args
)
134 const char *p
= args
;
139 if (check_for_argument (&p
, "--"))
142 p
= skip_to_space (p
);
150 /* Complete TEXT/WORD on all options in OPTIONS_GROUP. */
153 complete_on_options (gdb::array_view
<const option_def_group
> options_group
,
154 completion_tracker
&tracker
,
155 const char *text
, const char *word
)
157 size_t textlen
= strlen (text
);
158 for (const auto &grp
: options_group
)
159 for (const auto &opt
: grp
.options
)
160 if (strncmp (opt
.name
, text
, textlen
) == 0)
162 tracker
.add_completion
163 (make_completion_match_str (opt
.name
, text
, word
));
167 /* See cli-option.h. */
170 complete_on_all_options (completion_tracker
&tracker
,
171 gdb::array_view
<const option_def_group
> options_group
)
173 static const char opt
[] = "-";
174 complete_on_options (options_group
, tracker
, opt
+ 1, opt
);
177 /* Parse ARGS, guided by OPTIONS_GROUP. HAVE_DELIMITER is true if the
178 whole ARGS line included the "--" options-terminator delimiter. */
180 static gdb::optional
<option_def_and_value
>
181 parse_option (gdb::array_view
<const option_def_group
> options_group
,
182 process_options_mode mode
,
185 parse_option_completion_info
*completion
= nullptr)
187 if (*args
== nullptr)
189 else if (**args
!= '-')
192 error (_("Unrecognized option at: %s"), *args
);
195 else if (check_for_argument (args
, "--"))
198 /* Skip the initial '-'. */
199 const char *arg
= *args
+ 1;
201 const char *after
= skip_to_space (arg
);
202 size_t len
= after
- arg
;
203 const option_def
*match
= nullptr;
204 void *match_ctx
= nullptr;
206 for (const auto &grp
: options_group
)
208 for (const auto &o
: grp
.options
)
210 if (strncmp (o
.name
, arg
, len
) == 0)
212 if (match
!= nullptr)
214 if (completion
!= nullptr && arg
[len
] == '\0')
216 complete_on_options (options_group
,
218 arg
, completion
->word
);
222 error (_("Ambiguous option at: -%s"), arg
);
228 if ((isspace (arg
[len
]) || arg
[len
] == '\0')
229 && strlen (o
.name
) == len
)
230 break; /* Exact match. */
235 if (match
== nullptr)
237 if (have_delimiter
|| mode
!= PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
)
238 error (_("Unrecognized option at: %s"), *args
);
243 if (completion
!= nullptr && arg
[len
] == '\0')
245 complete_on_options (options_group
, completion
->tracker
,
246 arg
, completion
->word
);
251 *args
= skip_spaces (*args
);
252 if (completion
!= nullptr)
253 completion
->word
= *args
;
259 if (!match
->have_argument
)
263 return option_def_and_value
{*match
, match_ctx
, val
};
266 const char *val_str
= *args
;
269 if (**args
== '\0' && completion
!= nullptr)
271 /* Complete on both "on/off" and more options. */
273 if (mode
== PROCESS_OPTIONS_REQUIRE_DELIMITER
)
275 complete_on_enum (completion
->tracker
,
276 boolean_enums
, val_str
, val_str
);
277 complete_on_all_options (completion
->tracker
, options_group
);
279 return option_def_and_value
{*match
, match_ctx
};
281 else if (**args
== '-')
284 "cmd -boolean-option -another-opt..."
286 "cmd -boolean-option on -another-opt..."
290 else if (**args
== '\0')
293 (1) "cmd -boolean-option "
295 (1) "cmd -boolean-option on"
301 res
= parse_cli_boolean_value (args
);
304 const char *end
= skip_to_space (*args
);
305 if (completion
!= nullptr)
309 complete_on_enum (completion
->tracker
,
310 boolean_enums
, val_str
, val_str
);
311 return option_def_and_value
{*match
, match_ctx
};
316 error (_("Value given for `-%s' is not a boolean: %.*s"),
317 match
->name
, (int) (end
- val_str
), val_str
);
318 /* The user didn't separate options from operands
319 using "--", so treat this unrecognized value as the
320 start of the operands. This makes "frame apply all
321 -past-main CMD" work. */
322 return option_def_and_value
{*match
, match_ctx
};
324 else if (completion
!= nullptr && **args
== '\0')
326 /* While "cmd -boolean [TAB]" only offers "on" and
327 "off", the boolean option actually accepts "1",
328 "yes", etc. as boolean values. We complete on all
329 of those instead of BOOLEAN_ENUMS here to make
332 "p -object 1[TAB]" -> "p -object 1 "
333 "p -object ye[TAB]" -> "p -object yes "
335 Etc. Note that it's important that the space is
336 auto-appended. Otherwise, if we only completed on
337 on/off here, then it might look to the user like
338 "1" isn't valid, like:
339 "p -object 1[TAB]" -> "p -object 1" (i.e., nothing happens).
341 static const char *const all_boolean_enums
[] = {
348 complete_on_enum (completion
->tracker
, all_boolean_enums
,
356 return option_def_and_value
{*match
, match_ctx
, val
};
359 case var_zuinteger_unlimited
:
361 if (completion
!= nullptr)
365 /* Convenience to let the user know what the option
366 can accept. Note there's no common prefix between
367 the strings on purpose, so that readline doesn't do
369 completion
->tracker
.add_completion
370 (make_unique_xstrdup ("NUMBER"));
371 completion
->tracker
.add_completion
372 (make_unique_xstrdup ("unlimited"));
375 else if (startswith ("unlimited", *args
))
377 completion
->tracker
.add_completion
378 (make_unique_xstrdup ("unlimited"));
383 if (match
->type
== var_zuinteger_unlimited
)
386 val
.integer
= parse_cli_var_zuinteger_unlimited (args
, false);
387 return option_def_and_value
{*match
, match_ctx
, val
};
392 val
.uinteger
= parse_cli_var_uinteger (match
->type
, args
, false);
393 return option_def_and_value
{*match
, match_ctx
, val
};
398 if (completion
!= nullptr)
400 const char *after_arg
= skip_to_space (*args
);
401 if (*after_arg
== '\0')
403 complete_on_enum (completion
->tracker
,
404 match
->enums
, *args
, *args
);
405 if (completion
->tracker
.have_completions ())
408 /* If we don't have completions, let the
409 non-completion path throw on invalid enum value
410 below, so that completion processing stops. */
414 if (check_for_argument (args
, "--"))
416 /* Treat e.g., "backtrace -entry-values --" as if there
417 was no argument after "-entry-values". This makes
418 parse_cli_var_enum throw an error with a suggestion of
419 what are the valid options. */
424 val
.enumeration
= parse_cli_var_enum (args
, match
->enums
);
425 return option_def_and_value
{*match
, match_ctx
, val
};
429 if (check_for_argument (args
, "--"))
431 /* Treat e.g., "maint test-options -string --" as if there
432 was no argument after "-string". */
433 error (_("-%s requires an argument"), match
->name
);
436 const char *arg_start
= *args
;
437 std::string str
= extract_string_maybe_quoted (args
);
438 if (*args
== arg_start
)
439 error (_("-%s requires an argument"), match
->name
);
442 val
.string
= xstrdup (str
.c_str ());
443 return option_def_and_value
{*match
, match_ctx
, val
};
448 gdb_assert_not_reached (_("option type not supported"));
454 /* See cli-option.h. */
457 complete_options (completion_tracker
&tracker
,
459 process_options_mode mode
,
460 gdb::array_view
<const option_def_group
> options_group
)
462 const char *text
= *args
;
464 tracker
.set_use_custom_word_point (true);
466 const char *delimiter
= find_end_options_delimiter (text
);
467 bool have_delimiter
= delimiter
!= nullptr;
469 if (text
[0] == '-' && (!have_delimiter
|| *delimiter
== '\0'))
471 parse_option_completion_info completion_info
{nullptr, tracker
};
475 *args
= skip_spaces (*args
);
476 completion_info
.word
= *args
;
478 if (strcmp (*args
, "-") == 0)
480 complete_on_options (options_group
, tracker
, *args
+ 1,
481 completion_info
.word
);
483 else if (strcmp (*args
, "--") == 0)
485 tracker
.add_completion (make_unique_xstrdup (*args
));
487 else if (**args
== '-')
489 gdb::optional
<option_def_and_value
> ov
490 = parse_option (options_group
, mode
, have_delimiter
,
491 args
, &completion_info
);
492 if (!ov
&& !tracker
.have_completions ())
494 tracker
.advance_custom_word_point_by (*args
- text
);
495 return mode
== PROCESS_OPTIONS_REQUIRE_DELIMITER
;
499 && ov
->option
.type
== var_boolean
500 && !ov
->value
.has_value ())
502 /* Looked like a boolean option, but we failed to
503 parse the value. If this command requires a
504 delimiter, this value can't be the start of the
505 operands, so return true. Otherwise, if the
506 command doesn't require a delimiter return false
507 so that the caller tries to complete on the
509 tracker
.advance_custom_word_point_by (*args
- text
);
510 return mode
== PROCESS_OPTIONS_REQUIRE_DELIMITER
;
513 /* If we parsed an option with an argument, and reached
514 the end of the input string with no trailing space,
515 return true, so that our callers don't try to
516 complete anything by themselves. E.g., this makes it
519 (gdb) frame apply all -limit 10[TAB]
521 we don't try to complete on command names. */
523 && !tracker
.have_completions ()
525 && *args
> text
&& !isspace ((*args
)[-1]))
527 tracker
.advance_custom_word_point_by
532 /* If the caller passed in a context, then it is
533 interested in the option argument values. */
534 if (ov
&& ov
->ctx
!= nullptr)
535 save_option_value_in_ctx (ov
);
539 tracker
.advance_custom_word_point_by
540 (completion_info
.word
- text
);
542 /* If the command requires a delimiter, but we haven't
543 seen one, then return true, so that the caller
544 doesn't try to complete on whatever follows options,
545 which for these commands should only be done if
546 there's a delimiter. */
547 if (mode
== PROCESS_OPTIONS_REQUIRE_DELIMITER
550 /* If we reached the end of the input string, then
551 offer all options, since that's all the user can
553 if (completion_info
.word
[0] == '\0')
554 complete_on_all_options (tracker
, options_group
);
561 if (tracker
.have_completions ())
563 tracker
.advance_custom_word_point_by
564 (completion_info
.word
- text
);
569 else if (delimiter
!= nullptr)
571 tracker
.advance_custom_word_point_by (delimiter
- text
);
579 /* Save the parsed value in the option's context. */
582 save_option_value_in_ctx (gdb::optional
<option_def_and_value
> &ov
)
584 switch (ov
->option
.type
)
588 bool value
= ov
->value
.has_value () ? ov
->value
->boolean
: true;
589 *ov
->option
.var_address
.boolean (ov
->option
, ov
->ctx
) = value
;
593 *ov
->option
.var_address
.uinteger (ov
->option
, ov
->ctx
)
594 = ov
->value
->uinteger
;
596 case var_zuinteger_unlimited
:
597 *ov
->option
.var_address
.integer (ov
->option
, ov
->ctx
)
598 = ov
->value
->integer
;
601 *ov
->option
.var_address
.enumeration (ov
->option
, ov
->ctx
)
602 = ov
->value
->enumeration
;
605 *ov
->option
.var_address
.string (ov
->option
, ov
->ctx
)
607 ov
->value
->string
= nullptr;
610 gdb_assert_not_reached ("unhandled option type");
614 /* See cli-option.h. */
617 process_options (const char **args
,
618 process_options_mode mode
,
619 gdb::array_view
<const option_def_group
> options_group
)
621 if (*args
== nullptr)
624 /* If ARGS starts with "-", look for a "--" sequence. If one is
625 found, then interpret everything up until the "--" as
626 'gdb::option'-style command line options. Otherwise, interpret
627 ARGS as possibly the command's operands. */
628 bool have_delimiter
= find_end_options_delimiter (*args
) != nullptr;
630 if (mode
== PROCESS_OPTIONS_REQUIRE_DELIMITER
&& !have_delimiter
)
633 bool processed_any
= false;
637 *args
= skip_spaces (*args
);
639 auto ov
= parse_option (options_group
, mode
, have_delimiter
, args
);
647 processed_any
= true;
649 save_option_value_in_ctx (ov
);
653 /* Helper for build_help. Return a fragment of a help string showing
654 OPT's possible values. Returns NULL if OPT doesn't take an
658 get_val_type_str (const option_def
&opt
, std::string
&buffer
)
660 if (!opt
.have_argument
)
668 case var_zuinteger_unlimited
:
669 return "NUMBER|unlimited";
673 for (size_t i
= 0; opt
.enums
[i
] != nullptr; i
++)
677 buffer
+= opt
.enums
[i
];
679 return buffer
.c_str ();
688 /* Helper for build_help. Appends an indented version of DOC into
692 append_indented_doc (const char *doc
, std::string
&help
)
695 const char *n
= strchr (p
, '\n');
700 help
.append (p
, n
- p
+ 1);
702 n
= strchr (p
, '\n');
708 /* Fill HELP with an auto-generated "help" string fragment for
712 build_help_option (gdb::array_view
<const option_def
> options
,
717 for (const auto &o
: options
)
719 if (o
.set_doc
== nullptr)
725 const char *val_type_str
= get_val_type_str (o
, buffer
);
726 if (val_type_str
!= nullptr)
729 help
+= val_type_str
;
732 append_indented_doc (o
.set_doc
, help
);
733 if (o
.help_doc
!= nullptr)
736 append_indented_doc (o
.help_doc
, help
);
741 /* See cli-option.h. */
744 build_help (const char *help_tmpl
,
745 gdb::array_view
<const option_def_group
> options_group
)
747 bool need_newlines
= false;
748 std::string help_str
;
750 const char *p
= strstr (help_tmpl
, "%OPTIONS%");
751 help_str
.assign (help_tmpl
, p
);
753 for (const auto &grp
: options_group
)
754 for (const auto &opt
: grp
.options
)
759 need_newlines
= true;
760 build_help_option (opt
, help_str
);
763 p
+= strlen ("%OPTIONS%");
769 /* See cli-option.h. */
772 add_setshow_cmds_for_options (command_class cmd_class
,
774 gdb::array_view
<const option_def
> options
,
775 struct cmd_list_element
**set_list
,
776 struct cmd_list_element
**show_list
)
778 for (const auto &option
: options
)
780 if (option
.type
== var_boolean
)
782 add_setshow_boolean_cmd (option
.name
, cmd_class
,
783 option
.var_address
.boolean (option
, data
),
784 option
.set_doc
, option
.show_doc
,
786 nullptr, option
.show_cmd_cb
,
787 set_list
, show_list
);
789 else if (option
.type
== var_uinteger
)
791 add_setshow_uinteger_cmd (option
.name
, cmd_class
,
792 option
.var_address
.uinteger (option
, data
),
793 option
.set_doc
, option
.show_doc
,
795 nullptr, option
.show_cmd_cb
,
796 set_list
, show_list
);
798 else if (option
.type
== var_zuinteger_unlimited
)
800 add_setshow_zuinteger_unlimited_cmd
801 (option
.name
, cmd_class
,
802 option
.var_address
.integer (option
, data
),
803 option
.set_doc
, option
.show_doc
,
805 nullptr, option
.show_cmd_cb
,
806 set_list
, show_list
);
808 else if (option
.type
== var_enum
)
810 add_setshow_enum_cmd (option
.name
, cmd_class
,
812 option
.var_address
.enumeration (option
, data
),
813 option
.set_doc
, option
.show_doc
,
815 nullptr, option
.show_cmd_cb
,
816 set_list
, show_list
);
818 else if (option
.type
== var_string
)
820 add_setshow_string_cmd (option
.name
, cmd_class
,
821 option
.var_address
.string (option
, data
),
822 option
.set_doc
, option
.show_doc
,
824 nullptr, option
.show_cmd_cb
,
825 set_list
, show_list
);
828 gdb_assert_not_reached (_("option type not handled"));
832 } /* namespace option */
833 } /* namespace gdb */