/* 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"
-
/* Prototypes for local functions. */
-static void undef_cmd_error (char *, char *);
+static void undef_cmd_error (const char *, const char *);
-static struct cmd_list_element *delete_cmd (char *name,
+static struct cmd_list_element *delete_cmd (const char *name,
struct cmd_list_element **list,
struct cmd_list_element **prehook,
struct cmd_list_element **prehookee,
struct cmd_list_element **posthook,
struct cmd_list_element **posthookee);
-static struct cmd_list_element *find_cmd (char *command,
+static struct cmd_list_element *find_cmd (const char *command,
int len,
struct cmd_list_element *clist,
int ignore_help_classes,
}
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
}
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_cfunc_ftype *cfunc)
{
return cmd->func == do_cfunc && cmd->function.cfunc == cfunc;
}
cmd->completer = completer; /* Ok. */
}
+/* See definition in commands.h. */
+
+void
+set_cmd_completer_handle_brkchars (struct cmd_list_element *cmd,
+ completer_ftype_void *completer_handle_brkchars)
+{
+ cmd->completer_handle_brkchars = completer_handle_brkchars;
+}
+
/* 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
of *LIST). */
struct cmd_list_element *
-add_cmd (char *name, enum command_class class, void (*fun) (char *, int),
- char *doc, struct cmd_list_element **list)
+add_cmd (const char *name, enum command_class theclass, cmd_cfunc_ftype *fun,
+ 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;
+ c->theclass = theclass;
set_cmd_cfunc (c, fun);
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->prefix = NULL;
c->abbrev_flag = 0;
set_cmd_completer (c, make_symbol_completion_list_fn);
+ 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;
}
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 (char *name, char *oldname, enum command_class class,
+add_alias_cmd (const char *name, const char *oldname, enum command_class theclass,
int abbrev_flag, struct cmd_list_element **list)
{
- /* Must do this since lookup_cmd tries to side-effect its first
- arg. */
- char *copied_name;
+ const char *tmp;
struct cmd_list_element *old;
struct cmd_list_element *c;
- copied_name = (char *) alloca (strlen (oldname) + 1);
- strcpy (copied_name, oldname);
- old = lookup_cmd (&copied_name, *list, "", 1, 1);
+ tmp = oldname;
+ old = lookup_cmd (&tmp, *list, "", 1, 1);
if (old == 0)
{
return 0;
}
- c = add_cmd (name, class, NULL, old->doc, list);
+ c = add_cmd (name, theclass, NULL, 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;
containing that list. */
struct cmd_list_element *
-add_prefix_cmd (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_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 (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_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;
DOC is the documentation string. */
static struct cmd_list_element *
-add_set_or_show_cmd (char *name,
+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, NULL, doc, list);
gdb_assert (type == set_cmd || type == show_cmd);
c->type = type;
structures. */
static void
-add_setshow_cmd_full (char *name,
- enum command_class class,
+add_setshow_cmd_full (const char *name,
+ 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)
which will contain the matching string (from ENUMLIST). */
void
-add_setshow_enum_cmd (char *name,
- enum command_class class,
+add_setshow_enum_cmd (const char *name,
+ 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,
variable which will contain the value. DOC is the documentation
string. FUNC is the corresponding callback. */
void
-add_setshow_auto_boolean_cmd (char *name,
- enum command_class class,
+add_setshow_auto_boolean_cmd (const char *name,
+ 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 (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 (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 (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 (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 (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 VEC (char_ptr) *
+integer_unlimited_completer (struct cmd_list_element *ignore,
+ const char *text, const char *word)
+{
+ static const char * const keywords[] =
+ {
+ "unlimited",
+ NULL,
+ };
+
+ return complete_on_enum (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 (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 (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 (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 (char *name,
- enum command_class class,
- unsigned int *var,
+add_setshow_zuinteger_unlimited_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_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 (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,
set to NULL. */
static struct cmd_list_element *
-delete_cmd (char *name, struct cmd_list_element **list,
+delete_cmd (const char *name, struct cmd_list_element **list,
struct cmd_list_element **prehook,
struct cmd_list_element **prehookee,
struct cmd_list_element **posthook,
*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 (char *name, void (*fun) (char *, int), char *doc)
+add_info (const char *name, cmd_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 (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 (char *name, enum command_class class, void (*fun) (char *, int),
- char *doc)
+add_com (const char *name, enum command_class theclass, cmd_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 (char *name, 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_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)
+ struct re_pattern_buffer *regex, const char *prefix)
{
struct cmd_list_element *c;
int returnvalue;
help_list. */
void
-help_cmd (char *command, struct ui_file *stream)
+help_cmd (const char *command, struct ui_file *stream)
{
struct cmd_list_element *c;
/* 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);
}
}
found in nfound. */
static struct cmd_list_element *
-find_cmd (char *command, int len, struct cmd_list_element *clist,
+find_cmd (const char *command, int len, struct cmd_list_element *clist,
int ignore_help_classes, int *nfound)
{
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
the struct cmd_list_element is NULL). */
struct cmd_list_element *
-lookup_cmd_1 (char **text, struct cmd_list_element *clist,
+lookup_cmd_1 (const char **text, struct cmd_list_element *clist,
struct cmd_list_element **result_list, int ignore_help_classes)
{
char *command;
int len, tmp, nfound;
struct cmd_list_element *found, *c;
- char *line = *text;
+ const char *line = *text;
while (**text == ' ' || **text == '\t')
(*text)++;
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)
- deprecated_cmd_warning (&line);
+ if (found->deprecated_warn_user)
+ deprecated_cmd_warning (line);
found = found->cmd_pointer;
}
/* If we found a prefix command, keep looking. */
/* All this hair to move the space to the front of cmdtype */
static void
-undef_cmd_error (char *cmdtype, char *q)
+undef_cmd_error (const char *cmdtype, const char *q)
{
error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
cmdtype,
the function field of the struct cmd_list_element is 0). */
struct cmd_list_element *
-lookup_cmd (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 0;
}
-/* We are here presumably because an alias or command in *TEXT is
+/* We are here presumably because an alias or command in TEXT is
deprecated and a warning message should be generated. This
- function decodes *TEXT and potentially generates a warning message
+ function decodes TEXT and potentially generates a warning message
as outlined below.
Example for 'set endian big' which has a fictitious alias 'seb'.
- If alias wasn't used in *TEXT, and the command is deprecated:
+ If alias wasn't used in TEXT, and the command is deprecated:
"warning: 'set endian big' is deprecated."
If alias was used, and only the alias is deprecated:
*/
void
-deprecated_cmd_warning (char **text)
+deprecated_cmd_warning (const char *text)
{
struct cmd_list_element *alias = NULL;
struct cmd_list_element *prefix_cmd = NULL;
struct cmd_list_element *cmd = NULL;
- if (!lookup_cmd_composition (*text, &alias, &prefix_cmd, &cmd))
+ if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
/* 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;
}
*/
int
-lookup_cmd_composition (char *text,
+lookup_cmd_composition (const char *text,
struct cmd_list_element **alias,
struct cmd_list_element **prefix_cmd,
struct cmd_list_element **cmd)
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 */
"oobar"; if WORD is "baz/foo", return "baz/foobar". */
VEC (char_ptr) *
-complete_on_cmdlist (struct cmd_list_element *list, char *text, char *word,
+complete_on_cmdlist (struct cmd_list_element *list,
+ const char *text, const char *word,
int ignore_help_classes)
{
struct cmd_list_element *ptr;
if (pass == 0)
{
- if ((ptr->flags & CMD_DEPRECATED) != 0)
+ if (ptr->cmd_deprecated)
{
saw_deprecated_match = 1;
continue;
VEC (char_ptr) *
complete_on_enum (const char *const *enumlist,
- char *text,
- char *word)
+ const char *text, const char *word)
{
VEC (char_ptr) *matchlist = NULL;
int textlen = strlen (text);
cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
{
if (cmd_func_p (cmd))
- (*cmd->func) (cmd, args, from_tty);
+ {
+ struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
+
+ if (cmd->suppress_notification != NULL)
+ {
+ make_cleanup_restore_integer (cmd->suppress_notification);
+ *cmd->suppress_notification = 1;
+ }
+
+ (*cmd->func) (cmd, args, from_tty);
+
+ do_cleanups (cleanups);
+ }
else
error (_("Invalid command"));
}
+
+int
+cli_user_command_p (struct cmd_list_element *cmd)
+{
+ return (cmd->theclass == class_user
+ && (cmd->func == do_cfunc || cmd->func == do_sfunc));
+}
projects / thirdparty / binutils-gdb.git / blobdiff