/* 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 . */ #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 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 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 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 options_group) { static const char opt[] = "-"; complete_on_options (options_group, tracker, opt + 1, opt); } /* Parse ARGS, guided by OPTIONS_GROUP. HAVE_DELIMITER is true if the whole ARGS line included the "--" options-terminator delimiter. */ static gdb::optional parse_option (gdb::array_view 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 = nullptr; 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 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 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 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 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 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 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 */