/* Handle lists of commands, their decoding and documentation, for GDB.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 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
#include "symtab.h"
#include <ctype.h>
#include "gdb_regex.h"
-#include "gdb_string.h"
#include "completer.h"
#include "ui-out.h"
-
#include "cli/cli-cmds.h"
#include "cli/cli-decode.h"
-
-#ifdef TUI
-#include "tui/tui.h" /* For tui_active et al. */
-#endif
-
-#include "gdb_assert.h"
+#include "common/gdb_optional.h"
/* Prototypes for local functions. */
}
static void
-print_help_for_command (struct cmd_list_element *c, char *prefix, int recurse,
- struct ui_file *stream);
+print_help_for_command (struct cmd_list_element *c, const char *prefix,
+ int recurse, struct ui_file *stream);
\f
/* Set the callback function for the specified command. For each both
bounce function (unless cfunc / sfunc is NULL that is). */
static void
-do_cfunc (struct cmd_list_element *c, char *args, int from_tty)
+do_const_cfunc (struct cmd_list_element *c, char *args, int from_tty)
{
- c->function.cfunc (args, from_tty); /* Ok. */
+ c->function.const_cfunc (args, from_tty);
}
-void
-set_cmd_cfunc (struct cmd_list_element *cmd, cmd_cfunc_ftype *cfunc)
+static void
+set_cmd_cfunc (struct cmd_list_element *cmd, cmd_const_cfunc_ftype *cfunc)
{
if (cfunc == NULL)
cmd->func = NULL;
else
- cmd->func = do_cfunc;
- cmd->function.cfunc = cfunc; /* Ok. */
+ cmd->func = do_const_cfunc;
+ cmd->function.const_cfunc = cfunc;
}
static void
do_sfunc (struct cmd_list_element *c, char *args, int from_tty)
{
- c->function.sfunc (args, from_tty, c); /* Ok. */
+ c->function.sfunc (args, from_tty, c);
}
void
cmd->func = NULL;
else
cmd->func = do_sfunc;
- cmd->function.sfunc = sfunc; /* Ok. */
+ cmd->function.sfunc = sfunc;
}
int
-cmd_cfunc_eq (struct cmd_list_element *cmd,
- void (*cfunc) (char *args, int from_tty))
+cmd_cfunc_eq (struct cmd_list_element *cmd, cmd_const_cfunc_ftype *cfunc)
{
- return cmd->func == do_cfunc && cmd->function.cfunc == cfunc;
+ return cmd->func == do_const_cfunc && cmd->function.const_cfunc == cfunc;
}
void
cmd->completer = completer; /* Ok. */
}
+/* See definition in commands.h. */
+
+void
+set_cmd_completer_handle_brkchars (struct cmd_list_element *cmd,
+ completer_handle_brkchars_ftype *func)
+{
+ cmd->completer_handle_brkchars = func;
+}
+
/* Add element named NAME.
Space for NAME and DOC must be allocated by the caller.
CLASS is the top level category into which commands are broken down
Returns a pointer to the added command (not necessarily the head
of *LIST). */
-struct cmd_list_element *
-add_cmd (const char *name, enum command_class class, void (*fun) (char *, int),
- char *doc, struct cmd_list_element **list)
+static struct cmd_list_element *
+do_add_cmd (const char *name, enum command_class theclass,
+ const char *doc, struct cmd_list_element **list)
{
- struct cmd_list_element *c
- = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
+ struct cmd_list_element *c = XNEW (struct cmd_list_element);
struct cmd_list_element *p, *iter;
/* Turn each alias of the old command into an alias of the new
}
c->name = name;
- c->class = class;
- set_cmd_cfunc (c, fun);
+ c->theclass = theclass;
set_cmd_context (c, NULL);
c->doc = doc;
- c->flags = 0;
+ c->cmd_deprecated = 0;
+ c->deprecated_warn_user = 0;
+ c->malloced_replacement = 0;
+ c->doc_allocated = 0;
c->replacement = NULL;
c->pre_show_hook = NULL;
c->hook_in = 0;
c->allow_unknown = 0;
c->prefix = NULL;
c->abbrev_flag = 0;
- set_cmd_completer (c, make_symbol_completion_list_fn);
+ set_cmd_completer (c, symbol_completer);
+ c->completer_handle_brkchars = NULL;
c->destroyer = NULL;
c->type = not_set_cmd;
c->var = NULL;
c->user_commands = NULL;
c->cmd_pointer = NULL;
c->alias_chain = NULL;
+ c->suppress_notification = NULL;
return c;
}
+struct cmd_list_element *
+add_cmd (const char *name, enum command_class theclass,
+ const char *doc, struct cmd_list_element **list)
+{
+ cmd_list_element *result = do_add_cmd (name, theclass, doc, list);
+ result->func = NULL;
+ result->function.const_cfunc = NULL;
+ return result;
+}
+
+struct cmd_list_element *
+add_cmd (const char *name, enum command_class theclass,
+ cmd_const_cfunc_ftype *fun,
+ const char *doc, struct cmd_list_element **list)
+{
+ cmd_list_element *result = do_add_cmd (name, theclass, doc, list);
+ set_cmd_cfunc (result, fun);
+ return result;
+}
+
/* Deprecates a command CMD.
REPLACEMENT is the name of the command which should be used in
place of this command, or NULL if no such command exists.
Returns a pointer to the deprecated command. */
struct cmd_list_element *
-deprecate_cmd (struct cmd_list_element *cmd, char *replacement)
+deprecate_cmd (struct cmd_list_element *cmd, const char *replacement)
{
- cmd->flags |= (CMD_DEPRECATED | DEPRECATED_WARN_USER);
+ cmd->cmd_deprecated = 1;
+ cmd->deprecated_warn_user = 1;
if (replacement != NULL)
cmd->replacement = replacement;
}
struct cmd_list_element *
-add_alias_cmd (const char *name, const char *oldname, enum command_class class,
- int abbrev_flag, struct cmd_list_element **list)
+add_alias_cmd (const char *name, cmd_list_element *old,
+ enum command_class theclass, int abbrev_flag,
+ struct cmd_list_element **list)
{
- const char *tmp;
- struct cmd_list_element *old;
- struct cmd_list_element *c;
-
- tmp = oldname;
- old = lookup_cmd (&tmp, *list, "", 1, 1);
-
if (old == 0)
{
struct cmd_list_element *prehook, *prehookee, *posthook, *posthookee;
return 0;
}
- c = add_cmd (name, class, NULL, old->doc, list);
+ struct cmd_list_element *c = add_cmd (name, theclass, old->doc, list);
/* If OLD->DOC can be freed, we should make another copy. */
- if ((old->flags & DOC_ALLOCATED) != 0)
+ if (old->doc_allocated)
{
c->doc = xstrdup (old->doc);
- c->flags |= DOC_ALLOCATED;
+ c->doc_allocated = 1;
}
/* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
c->func = old->func;
return c;
}
+struct cmd_list_element *
+add_alias_cmd (const char *name, const char *oldname,
+ enum command_class theclass, int abbrev_flag,
+ struct cmd_list_element **list)
+{
+ const char *tmp;
+ struct cmd_list_element *old;
+
+ tmp = oldname;
+ old = lookup_cmd (&tmp, *list, "", 1, 1);
+
+ return add_alias_cmd (name, old, theclass, abbrev_flag, list);
+}
+
+
/* Like add_cmd but adds an element for a command prefix: a name that
should be followed by a subcommand to be looked up in another
command list. PREFIXLIST should be the address of the variable
containing that list. */
struct cmd_list_element *
-add_prefix_cmd (const char *name, enum command_class class,
- void (*fun) (char *, int),
- char *doc, struct cmd_list_element **prefixlist,
- char *prefixname, int allow_unknown,
+add_prefix_cmd (const char *name, enum command_class theclass,
+ cmd_const_cfunc_ftype *fun,
+ const char *doc, struct cmd_list_element **prefixlist,
+ const char *prefixname, int allow_unknown,
struct cmd_list_element **list)
{
- struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
+ struct cmd_list_element *c = add_cmd (name, theclass, fun, doc, list);
struct cmd_list_element *p;
c->prefixlist = prefixlist;
/* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
struct cmd_list_element *
-add_abbrev_prefix_cmd (const char *name, enum command_class class,
- void (*fun) (char *, int), char *doc,
- struct cmd_list_element **prefixlist, char *prefixname,
+add_abbrev_prefix_cmd (const char *name, enum command_class theclass,
+ cmd_const_cfunc_ftype *fun, const char *doc,
+ struct cmd_list_element **prefixlist,
+ const char *prefixname,
int allow_unknown, struct cmd_list_element **list)
{
- struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
+ struct cmd_list_element *c = add_cmd (name, theclass, fun, doc, list);
c->prefixlist = prefixlist;
c->prefixname = prefixname;
/* This is an empty "cfunc". */
void
-not_just_help_class_command (char *args, int from_tty)
+not_just_help_class_command (const char *args, int from_tty)
{
}
static struct cmd_list_element *
add_set_or_show_cmd (const char *name,
enum cmd_types type,
- enum command_class class,
+ enum command_class theclass,
var_types var_type,
void *var,
- char *doc,
+ const char *doc,
struct cmd_list_element **list)
{
- struct cmd_list_element *c = add_cmd (name, class, NULL, doc, list);
+ struct cmd_list_element *c = add_cmd (name, theclass, doc, list);
gdb_assert (type == set_cmd || type == show_cmd);
c->type = type;
static void
add_setshow_cmd_full (const char *name,
- enum command_class class,
+ enum command_class theclass,
var_types var_type, void *var,
const char *set_doc, const char *show_doc,
const char *help_doc,
full_set_doc = xstrdup (set_doc);
full_show_doc = xstrdup (show_doc);
}
- set = add_set_or_show_cmd (name, set_cmd, class, var_type, var,
+ set = add_set_or_show_cmd (name, set_cmd, theclass, var_type, var,
full_set_doc, set_list);
- set->flags |= DOC_ALLOCATED;
+ set->doc_allocated = 1;
if (set_func != NULL)
set_cmd_sfunc (set, set_func);
set_cmd_prefix (set, set_list);
- show = add_set_or_show_cmd (name, show_cmd, class, var_type, var,
+ show = add_set_or_show_cmd (name, show_cmd, theclass, var_type, var,
full_show_doc, show_list);
- show->flags |= DOC_ALLOCATED;
+ show->doc_allocated = 1;
show->show_value_func = show_func;
if (set_result != NULL)
void
add_setshow_enum_cmd (const char *name,
- enum command_class class,
+ enum command_class theclass,
const char *const *enumlist,
const char **var,
const char *set_doc,
{
struct cmd_list_element *c;
- add_setshow_cmd_full (name, class, var_enum, var,
+ add_setshow_cmd_full (name, theclass, var_enum, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
string. FUNC is the corresponding callback. */
void
add_setshow_auto_boolean_cmd (const char *name,
- enum command_class class,
+ enum command_class theclass,
enum auto_boolean *var,
const char *set_doc, const char *show_doc,
const char *help_doc,
{
struct cmd_list_element *c;
- add_setshow_cmd_full (name, class, var_auto_boolean, var,
+ add_setshow_cmd_full (name, theclass, var_auto_boolean, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
add_cmd. VAR is address of the variable which will contain the
value. SET_DOC and SHOW_DOC are the documentation strings. */
void
-add_setshow_boolean_cmd (const char *name, enum command_class class, int *var,
+add_setshow_boolean_cmd (const char *name, enum command_class theclass, int *var,
const char *set_doc, const char *show_doc,
const char *help_doc,
cmd_sfunc_ftype *set_func,
static const char *boolean_enums[] = { "on", "off", NULL };
struct cmd_list_element *c;
- add_setshow_cmd_full (name, class, var_boolean, var,
+ add_setshow_cmd_full (name, theclass, var_boolean, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
/* Add element named NAME to both the set and show command LISTs (the
list for set/show or some sublist thereof). */
void
-add_setshow_filename_cmd (const char *name, enum command_class class,
+add_setshow_filename_cmd (const char *name, enum command_class theclass,
char **var,
const char *set_doc, const char *show_doc,
const char *help_doc,
{
struct cmd_list_element *set_result;
- add_setshow_cmd_full (name, class, var_filename, var,
+ add_setshow_cmd_full (name, theclass, var_filename, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
/* Add element named NAME to both the set and show command LISTs (the
list for set/show or some sublist thereof). */
void
-add_setshow_string_cmd (const char *name, enum command_class class,
+add_setshow_string_cmd (const char *name, enum command_class theclass,
char **var,
const char *set_doc, const char *show_doc,
const char *help_doc,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list)
{
- add_setshow_cmd_full (name, class, var_string, var,
+ add_setshow_cmd_full (name, theclass, var_string, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
/* Add element named NAME to both the set and show command LISTs (the
list for set/show or some sublist thereof). */
struct cmd_list_element *
-add_setshow_string_noescape_cmd (const char *name, enum command_class class,
+add_setshow_string_noescape_cmd (const char *name, enum command_class theclass,
char **var,
const char *set_doc, const char *show_doc,
const char *help_doc,
{
struct cmd_list_element *set_cmd;
- add_setshow_cmd_full (name, class, var_string_noescape, var,
+ add_setshow_cmd_full (name, theclass, var_string_noescape, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
/* Add element named NAME to both the set and show command LISTs (the
list for set/show or some sublist thereof). */
void
-add_setshow_optional_filename_cmd (const char *name, enum command_class class,
+add_setshow_optional_filename_cmd (const char *name, enum command_class theclass,
char **var,
const char *set_doc, const char *show_doc,
const char *help_doc,
{
struct cmd_list_element *set_result;
- add_setshow_cmd_full (name, class, var_optional_filename, var,
+ add_setshow_cmd_full (name, theclass, var_optional_filename, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
}
+/* Completes on literal "unlimited". Used by integer commands that
+ support a special "unlimited" value. */
+
+static void
+integer_unlimited_completer (struct cmd_list_element *ignore,
+ completion_tracker &tracker,
+ const char *text, const char *word)
+{
+ static const char * const keywords[] =
+ {
+ "unlimited",
+ NULL,
+ };
+
+ complete_on_enum (tracker, keywords, text, word);
+}
+
/* 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
value. SET_DOC and SHOW_DOC are the documentation strings. This
function is only used in Python API. Please don't use it elsewhere. */
void
-add_setshow_integer_cmd (const char *name, enum command_class class,
+add_setshow_integer_cmd (const char *name, enum command_class theclass,
int *var,
const char *set_doc, const char *show_doc,
const char *help_doc,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list)
{
- add_setshow_cmd_full (name, class, var_integer, var,
+ struct cmd_list_element *set;
+
+ add_setshow_cmd_full (name, theclass, var_integer, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
- NULL, NULL);
+ &set, NULL);
+
+ set_cmd_completer (set, integer_unlimited_completer);
}
/* Add element named NAME to both the set and show command LISTs (the
add_cmd. VAR is address of the variable which will contain the
value. SET_DOC and SHOW_DOC are the documentation strings. */
void
-add_setshow_uinteger_cmd (const char *name, enum command_class class,
+add_setshow_uinteger_cmd (const char *name, enum command_class theclass,
unsigned int *var,
const char *set_doc, const char *show_doc,
const char *help_doc,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list)
{
- add_setshow_cmd_full (name, class, var_uinteger, var,
+ struct cmd_list_element *set;
+
+ add_setshow_cmd_full (name, theclass, var_uinteger, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
- NULL, NULL);
+ &set, NULL);
+
+ set_cmd_completer (set, integer_unlimited_completer);
}
/* Add element named NAME to both the set and show command LISTs (the
add_cmd. VAR is address of the variable which will contain the
value. SET_DOC and SHOW_DOC are the documentation strings. */
void
-add_setshow_zinteger_cmd (const char *name, enum command_class class,
+add_setshow_zinteger_cmd (const char *name, enum command_class theclass,
int *var,
const char *set_doc, const char *show_doc,
const char *help_doc,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list)
{
- add_setshow_cmd_full (name, class, var_zinteger, var,
+ add_setshow_cmd_full (name, theclass, var_zinteger, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
void
add_setshow_zuinteger_unlimited_cmd (const char *name,
- enum command_class class,
+ enum command_class theclass,
int *var,
const char *set_doc,
const char *show_doc,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list)
{
- add_setshow_cmd_full (name, class, var_zuinteger_unlimited, var,
+ struct cmd_list_element *set;
+
+ add_setshow_cmd_full (name, theclass, var_zuinteger_unlimited, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
- NULL, NULL);
+ &set, NULL);
+
+ set_cmd_completer (set, integer_unlimited_completer);
}
/* Add element named NAME to both the set and show command LISTs (the
add_cmd. VAR is address of the variable which will contain the
value. SET_DOC and SHOW_DOC are the documentation strings. */
void
-add_setshow_zuinteger_cmd (const char *name, enum command_class class,
+add_setshow_zuinteger_cmd (const char *name, enum command_class theclass,
unsigned int *var,
const char *set_doc, const char *show_doc,
const char *help_doc,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list)
{
- add_setshow_cmd_full (name, class, var_zuinteger, var,
+ add_setshow_cmd_full (name, theclass, var_zuinteger, var,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
*prehookee = iter->hookee_pre;
if (iter->hookee_post)
iter->hookee_post->hook_post = 0;
- if (iter->doc && (iter->flags & DOC_ALLOCATED) != 0)
- xfree (iter->doc);
+ if (iter->doc && iter->doc_allocated)
+ xfree ((char *) iter->doc);
*posthook = iter->hook_post;
*posthookee = iter->hookee_post;
/* Add an element to the list of info subcommands. */
struct cmd_list_element *
-add_info (const char *name, void (*fun) (char *, int), char *doc)
+add_info (const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
{
- return add_cmd (name, no_class, fun, doc, &infolist);
+ return add_cmd (name, class_info, fun, doc, &infolist);
}
/* Add an alias to the list of info subcommands. */
struct cmd_list_element *
-add_info_alias (const char *name, char *oldname, int abbrev_flag)
+add_info_alias (const char *name, const char *oldname, int abbrev_flag)
{
- return add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
+ return add_alias_cmd (name, oldname, class_run, abbrev_flag, &infolist);
}
/* Add an element to the list of commands. */
struct cmd_list_element *
-add_com (const char *name, enum command_class class, void (*fun) (char *, int),
- char *doc)
+add_com (const char *name, enum command_class theclass,
+ cmd_const_cfunc_ftype *fun,
+ const char *doc)
{
- return add_cmd (name, class, fun, doc, &cmdlist);
+ return add_cmd (name, theclass, fun, doc, &cmdlist);
}
/* Add an alias or abbreviation command to the list of commands. */
struct cmd_list_element *
-add_com_alias (const char *name, const char *oldname, enum command_class class,
+add_com_alias (const char *name, const char *oldname, enum command_class theclass,
int abbrev_flag)
{
- return add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
+ return add_alias_cmd (name, oldname, theclass, abbrev_flag, &cmdlist);
}
-\f
+
+/* Add an element with a suppress notification to the list of commands. */
+
+struct cmd_list_element *
+add_com_suppress_notification (const char *name, enum command_class theclass,
+ cmd_const_cfunc_ftype *fun, const char *doc,
+ int *suppress_notification)
+{
+ struct cmd_list_element *element;
+
+ element = add_cmd (name, theclass, fun, doc, &cmdlist);
+ element->suppress_notification = suppress_notification;
+
+ return element;
+}
+
/* Recursively walk the commandlist structures, and print out the
documentation of commands that match our regex in either their
name, or their documentation.
void
apropos_cmd (struct ui_file *stream,
struct cmd_list_element *commandlist,
- struct re_pattern_buffer *regex, char *prefix)
+ compiled_regex ®ex, const char *prefix)
{
struct cmd_list_element *c;
int returnvalue;
returnvalue = -1; /* Needed to avoid double printing. */
if (c->name != NULL)
{
+ size_t name_len = strlen (c->name);
+
/* Try to match against the name. */
- returnvalue = re_search (regex, c->name, strlen(c->name),
- 0, strlen (c->name), NULL);
+ returnvalue = regex.search (c->name, name_len, 0, name_len, NULL);
if (returnvalue >= 0)
{
print_help_for_command (c, prefix,
}
if (c->doc != NULL && returnvalue < 0)
{
+ size_t doc_len = strlen (c->doc);
+
/* Try to match against documentation. */
- if (re_search(regex,c->doc,strlen(c->doc),0,strlen(c->doc),NULL) >=0)
+ if (regex.search (c->doc, doc_len, 0, doc_len, NULL) >= 0)
{
print_help_for_command (c, prefix,
0 /* don't recurse */, stream);
help_list. */
void
-help_cmd (char *arg, struct ui_file *stream)
+help_cmd (const char *command, struct ui_file *stream)
{
struct cmd_list_element *c;
- const char *command = arg;
if (!command)
{
/* If this is a class name, print all of the commands in the class. */
if (c->func == NULL)
- help_list (cmdlist, "", c->class, stream);
+ help_list (cmdlist, "", c->theclass, stream);
if (c->hook_pre || c->hook_post)
fprintf_filtered (stream,
* If you call this routine with a class >= 0, it recurses.
*/
void
-help_list (struct cmd_list_element *list, char *cmdtype,
- enum command_class class, struct ui_file *stream)
+help_list (struct cmd_list_element *list, const char *cmdtype,
+ enum command_class theclass, struct ui_file *stream)
{
int len;
char *cmdtype1, *cmdtype2;
strcpy (cmdtype2 + len - 1, " sub");
}
- if (class == all_classes)
+ if (theclass == all_classes)
fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2);
else
fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);
- help_cmd_list (list, class, cmdtype, (int) class >= 0, stream);
+ help_cmd_list (list, theclass, cmdtype, (int) theclass >= 0, stream);
- if (class == all_classes)
+ if (theclass == all_classes)
{
fprintf_filtered (stream, "\n\
Type \"help%s\" followed by a class name for a list of commands in ",
if (c->func == NULL)
{
fprintf_filtered (stream, "\nCommand class: %s\n\n", c->name);
- help_cmd_list (cmdlist, c->class, "", 1, stream);
+ help_cmd_list (cmdlist, c->theclass, "", 1, stream);
}
}
if (c->abbrev_flag)
continue;
- if (c->class == no_class)
+ if (c->theclass == no_class)
{
if (!seen_unclassified)
{
/* Print only the first line of STR on STREAM. */
void
-print_doc_line (struct ui_file *stream, char *str)
+print_doc_line (struct ui_file *stream, const char *str)
{
static char *line_buffer = 0;
static int line_size;
- char *p;
+ const char *p;
if (!line_buffer)
{
If RECURSE is non-zero, also print one-line descriptions
of all prefixed subcommands. */
static void
-print_help_for_command (struct cmd_list_element *c, char *prefix, int recurse,
- struct ui_file *stream)
+print_help_for_command (struct cmd_list_element *c, const char *prefix,
+ int recurse, struct ui_file *stream)
{
fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
print_doc_line (stream, c->doc);
* all sublists of LIST.
* PREFIX is the prefix to print before each command name.
* STREAM is the stream upon which the output should be written.
- * CLASS should be:
+ * THECLASS should be:
* A non-negative class number to list only commands in that
* class.
* ALL_COMMANDS to list all commands in list.
* is at the low level, not the high-level).
*/
void
-help_cmd_list (struct cmd_list_element *list, enum command_class class,
- char *prefix, int recurse, struct ui_file *stream)
+help_cmd_list (struct cmd_list_element *list, enum command_class theclass,
+ const char *prefix, int recurse, struct ui_file *stream)
{
struct cmd_list_element *c;
for (c = list; c; c = c->next)
- {
+ {
if (c->abbrev_flag == 0
- && (class == all_commands
- || (class == all_classes && c->func == NULL)
- || (class == c->class && c->func != NULL)))
+ && !c->cmd_deprecated
+ && (theclass == all_commands
+ || (theclass == all_classes && c->func == NULL)
+ || (theclass == c->theclass && c->func != NULL)))
{
print_help_for_command (c, prefix, recurse, stream);
}
- else if (c->abbrev_flag == 0 && recurse
- && class == class_user && c->prefixlist != NULL)
+ else if (c->abbrev_flag == 0
+ && recurse
+ && !c->cmd_deprecated
+ && theclass == class_user && c->prefixlist != NULL)
/* User-defined commands may be subcommands. */
- help_cmd_list (*c->prefixlist, class, c->prefixname,
+ help_cmd_list (*c->prefixlist, theclass, c->prefixname,
recurse, stream);
}
}
{
struct cmd_list_element *found, *c;
- found = (struct cmd_list_element *) NULL;
+ found = NULL;
*nfound = 0;
for (c = clist; c; c = c->next)
if (!strncmp (command, c->name, len)
return found;
}
-static int
+/* Return the length of command name in TEXT. */
+
+int
find_command_name_length (const char *text)
{
const char *p = text;
/* Some characters are only used for TUI specific commands.
However, they are always allowed for the sake of consistency.
- The XDB compatibility characters are only allowed when using the
- right mode because they clash with other GDB commands -
- specifically '/' is used as a suffix for print, examine and
- display.
-
Note that this is larger than the character set allowed when
creating user-defined commands. */
while (isalnum (*p) || *p == '-' || *p == '_'
/* Characters used by TUI specific commands. */
- || *p == '+' || *p == '<' || *p == '>' || *p == '$'
- /* Characters used for XDB compatibility. */
- || (xdb_commands && (*p == '/' || *p == '?')))
+ || *p == '+' || *p == '<' || *p == '>' || *p == '$')
p++;
return p - text;
if no prefix command was ever found. For example, in the case of "info a",
"info" matches without ambiguity, but "a" could be "args" or "address", so
*RESULT_LIST is set to the cmd_list_element for "info". So in this case
- RESULT_LIST should not be interpeted as a pointer to the beginning of a
+ RESULT_LIST should not be interpreted as a pointer to the beginning of a
list; it simply points to a specific command. In the case of an ambiguous
return *TEXT is advanced past the last non-ambiguous prefix (e.g.
"info t" can be "info types" or "info target"; upon return *TEXT has been
nfound = 0;
found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
- /* We didn't find the command in the entered case, so lower case it
- and search again. */
- if (!found || nfound == 0)
- {
- for (tmp = 0; tmp < len; tmp++)
- {
- char x = command[tmp];
-
- command[tmp] = isupper (x) ? tolower (x) : x;
- }
- found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
- }
-
/* If nothing matches, we have a simple failure. */
if (nfound == 0)
return 0;
itself and we will adjust the appropriate DEPRECATED_WARN_USER
flags. */
- if (found->flags & DEPRECATED_WARN_USER)
+ if (found->deprecated_warn_user)
deprecated_cmd_warning (line);
found = found->cmd_pointer;
}
the function field of the struct cmd_list_element is 0). */
struct cmd_list_element *
-lookup_cmd (const char **line, struct cmd_list_element *list, char *cmdtype,
+lookup_cmd (const char **line, struct cmd_list_element *list,
+ const char *cmdtype,
int allow_unknown, int ignore_help_classes)
{
struct cmd_list_element *last_list = 0;
values. */
int local_allow_unknown = (last_list ? last_list->allow_unknown :
allow_unknown);
- char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
+ const char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
struct cmd_list_element *local_list =
(last_list ? *(last_list->prefixlist) : list);
}
else
{
+ if (c->type == set_cmd && **line != '\0' && !isspace (**line))
+ error (_("Argument must be preceded by space."));
+
/* We've got something. It may still not be what the caller
wants (if this command *needs* a subcommand). */
while (**line == ' ' || **line == '\t')
/* Return if text doesn't evaluate to a command. */
return;
- if (!((alias ? (alias->flags & DEPRECATED_WARN_USER) : 0)
- || (cmd->flags & DEPRECATED_WARN_USER) ) )
+ if (!((alias ? alias->deprecated_warn_user : 0)
+ || cmd->deprecated_warn_user) )
/* Return if nothing is deprecated. */
return;
printf_filtered ("Warning:");
- if (alias && !(cmd->flags & CMD_DEPRECATED))
+ if (alias && !cmd->cmd_deprecated)
printf_filtered (" '%s', an alias for the", alias->name);
printf_filtered (" command '");
printf_filtered ("%s", cmd->name);
- if (alias && (cmd->flags & CMD_DEPRECATED))
+ if (alias && cmd->cmd_deprecated)
printf_filtered ("' (%s) is deprecated.\n", alias->name);
else
printf_filtered ("' is deprecated.\n");
/* If it is only the alias that is deprecated, we want to indicate
the new alias, otherwise we'll indicate the new command. */
- if (alias && !(cmd->flags & CMD_DEPRECATED))
+ if (alias && !cmd->cmd_deprecated)
{
if (alias->replacement)
printf_filtered ("Use '%s'.\n\n", alias->replacement);
/* We've warned you, now we'll keep quiet. */
if (alias)
- alias->flags &= ~DEPRECATED_WARN_USER;
+ alias->deprecated_warn_user = 0;
- cmd->flags &= ~DEPRECATED_WARN_USER;
+ cmd->deprecated_warn_user = 0;
}
nfound = 0;
*cmd = find_cmd (command, len, cur_list, 1, &nfound);
- /* We didn't find the command in the entered case, so lower case
- it and search again.
- */
- if (!*cmd || nfound == 0)
- {
- for (tmp = 0; tmp < len; tmp++)
- {
- char x = command[tmp];
-
- command[tmp] = isupper (x) ? tolower (x) : x;
- }
- *cmd = find_cmd (command, len, cur_list, 1, &nfound);
- }
-
if (*cmd == CMD_LIST_AMBIGUOUS)
{
return 0; /* ambiguous */
"foo" and we want to complete to "foobar". If WORD is "oo", return
"oobar"; if WORD is "baz/foo", return "baz/foobar". */
-VEC (char_ptr) *
+void
complete_on_cmdlist (struct cmd_list_element *list,
+ completion_tracker &tracker,
const char *text, const char *word,
int ignore_help_classes)
{
struct cmd_list_element *ptr;
- VEC (char_ptr) *matchlist = NULL;
int textlen = strlen (text);
int pass;
int saw_deprecated_match = 0;
commands. If we see no matching commands in the first pass, and
if we did happen to see a matching deprecated command, we do
another loop to collect those. */
- for (pass = 0; matchlist == 0 && pass < 2; ++pass)
+ for (pass = 0; pass < 2; ++pass)
{
+ bool got_matches = false;
+
for (ptr = list; ptr; ptr = ptr->next)
if (!strncmp (ptr->name, text, textlen)
&& !ptr->abbrev_flag
if (pass == 0)
{
- if ((ptr->flags & CMD_DEPRECATED) != 0)
+ if (ptr->cmd_deprecated)
{
saw_deprecated_match = 1;
continue;
match[text - word] = '\0';
strcat (match, ptr->name);
}
- VEC_safe_push (char_ptr, matchlist, match);
+ tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
+ got_matches = true;
}
+
+ if (got_matches)
+ break;
+
/* If we saw no matching deprecated commands in the first pass,
just bail out. */
if (!saw_deprecated_match)
break;
}
-
- return matchlist;
}
/* Helper function for SYMBOL_COMPLETION_FUNCTION. */
-/* Return a vector of char pointers which point to the different
- possible completions in CMD of TEXT.
+/* Add the different possible completions in ENUMLIST of TEXT.
WORD points in the same buffer as TEXT, and completions should be
returned relative to this position. For example, suppose TEXT is "foo"
and we want to complete to "foobar". If WORD is "oo", return
"oobar"; if WORD is "baz/foo", return "baz/foobar". */
-VEC (char_ptr) *
-complete_on_enum (const char *const *enumlist,
+void
+complete_on_enum (completion_tracker &tracker,
+ const char *const *enumlist,
const char *text, const char *word)
{
- VEC (char_ptr) *matchlist = NULL;
int textlen = strlen (text);
int i;
const char *name;
match[text - word] = '\0';
strcat (match, name);
}
- VEC_safe_push (char_ptr, matchlist, match);
+ tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
}
-
- return matchlist;
}
cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
{
if (cmd_func_p (cmd))
- (*cmd->func) (cmd, args, from_tty);
+ {
+ gdb::optional<scoped_restore_tmpl<int>> restore_suppress;
+
+ if (cmd->suppress_notification != NULL)
+ restore_suppress.emplace (cmd->suppress_notification, 1);
+
+ (*cmd->func) (cmd, args, from_tty);
+ }
else
error (_("Invalid command"));
}
+
+int
+cli_user_command_p (struct cmd_list_element *cmd)
+{
+ return (cmd->theclass == class_user
+ && (cmd->func == do_const_cfunc || cmd->func == do_sfunc));
+}
projects / deliverable / binutils-gdb.git / blobdiff