/* Handle lists of commands, their decoding and documentation, for GDB.
- Copyright 1986, 1989, 1990, 1991, 1998, 2000, 2001, 2002 Free
- Software Foundation, Inc.
+ Copyright (c) 1986, 1989, 1990, 1991, 1998, 2000, 2001, 2002, 2004, 2007,
+ 2008, 2009 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ 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,
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, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#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 struct cmd_list_element *delete_cmd (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,
int len,
struct cmd_list_element *clist,
int *nfound);
static void help_all (struct ui_file *stream);
+
+static void
+print_help_for_command (struct cmd_list_element *c, char *prefix, int recurse,
+ struct ui_file *stream);
+
\f
/* Set the callback function for the specified command. For each both
the commands callback and func() are set. The latter set to a
void
set_cmd_completer (struct cmd_list_element *cmd,
- char **(*completer) (char *text, char *word))
+ char **(*completer) (struct cmd_list_element *self,
+ char *text, char *word))
{
cmd->completer = completer; /* Ok. */
}
add_cmd (char *name, enum command_class class, void (*fun) (char *, int),
char *doc, struct cmd_list_element **list)
{
- register struct cmd_list_element *c
+ struct cmd_list_element *c
= (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
- struct cmd_list_element *p;
-
- delete_cmd (name, list);
+ struct cmd_list_element *p, *iter;
+
+ /* Turn each alias of the old command into an alias of the new
+ command. */
+ c->aliases = delete_cmd (name, list, &c->hook_pre, &c->hookee_pre,
+ &c->hook_post, &c->hookee_post);
+ for (iter = c->aliases; iter; iter = iter->alias_chain)
+ iter->cmd_pointer = c;
+ if (c->hook_pre)
+ c->hook_pre->hookee_pre = c;
+ if (c->hookee_pre)
+ c->hookee_pre->hook_pre = c;
+ if (c->hook_post)
+ c->hook_post->hookee_post = c;
+ if (c->hookee_post)
+ c->hookee_post->hook_post = c;
if (*list == NULL || strcmp ((*list)->name, name) >= 0)
{
c->flags = 0;
c->replacement = NULL;
c->pre_show_hook = NULL;
- c->hook_pre = NULL;
- c->hook_post = NULL;
c->hook_in = 0;
c->prefixlist = NULL;
c->prefixname = NULL;
c->allow_unknown = 0;
c->abbrev_flag = 0;
- set_cmd_completer (c, make_symbol_completion_list);
+ set_cmd_completer (c, make_symbol_completion_list_fn);
+ c->destroyer = NULL;
c->type = not_set_cmd;
c->var = NULL;
c->var_type = var_boolean;
c->enums = NULL;
c->user_commands = NULL;
- c->hookee_pre = NULL;
- c->hookee_post = NULL;
c->cmd_pointer = NULL;
+ c->alias_chain = NULL;
return c;
}
-/* Same as above, except that the abbrev_flag is set. */
-/* Note: Doesn't seem to be used anywhere currently. */
-
-struct cmd_list_element *
-add_abbrev_cmd (char *name, enum command_class class, void (*fun) (char *, int),
- char *doc, struct cmd_list_element **list)
-{
- register struct cmd_list_element *c
- = add_cmd (name, class, fun, doc, list);
-
- c->abbrev_flag = 1;
- return c;
-}
-
/* 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.
{
/* Must do this since lookup_cmd tries to side-effect its first arg */
char *copied_name;
- register struct cmd_list_element *old;
- register struct cmd_list_element *c;
+ 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);
if (old == 0)
{
- delete_cmd (name, list);
+ struct cmd_list_element *prehook, *prehookee, *posthook, *posthookee;
+ struct cmd_list_element *aliases = delete_cmd (name, list,
+ &prehook, &prehookee,
+ &posthook, &posthookee);
+ /* If this happens, it means a programmer error somewhere. */
+ gdb_assert (!aliases && !prehook && !prehookee
+ && !posthook && ! posthookee);
return 0;
}
c->allow_unknown = old->allow_unknown;
c->abbrev_flag = abbrev_flag;
c->cmd_pointer = old;
+ c->alias_chain = old->aliases;
+ old->aliases = c;
return c;
}
char *prefixname, int allow_unknown,
struct cmd_list_element **list)
{
- register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
+ struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
c->prefixlist = prefixlist;
c->prefixname = prefixname;
c->allow_unknown = allow_unknown;
struct cmd_list_element **prefixlist, char *prefixname,
int allow_unknown, struct cmd_list_element **list)
{
- register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
+ struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
c->prefixlist = prefixlist;
c->prefixname = prefixname;
c->allow_unknown = allow_unknown;
CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
setting. VAR is address of the variable being controlled by this
command. SET_FUNC and SHOW_FUNC are the callback functions (if
- non-NULL). SET_DOC and SHOW_DOC are the documentation strings.
- SET_RESULT and SHOW_RESULT, if not NULL, are set to the resulting
- command structures. */
+ non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
+ strings. PRINT the format string to print the value. SET_RESULT
+ and SHOW_RESULT, if not NULL, are set to the resulting command
+ structures. */
-void
+static void
add_setshow_cmd_full (char *name,
enum command_class class,
var_types var_type, void *var,
- char *set_doc, char *show_doc,
- cmd_sfunc_ftype *set_func, cmd_sfunc_ftype *show_func,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list,
struct cmd_list_element **set_result,
{
struct cmd_list_element *set;
struct cmd_list_element *show;
+ char *full_set_doc;
+ char *full_show_doc;
+
+ if (help_doc != NULL)
+ {
+ full_set_doc = xstrprintf ("%s\n%s", set_doc, help_doc);
+ full_show_doc = xstrprintf ("%s\n%s", show_doc, help_doc);
+ }
+ else
+ {
+ 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_doc, set_list);
+ full_set_doc, set_list);
if (set_func != NULL)
set_cmd_sfunc (set, set_func);
show = add_set_or_show_cmd (name, show_cmd, class, var_type, var,
- show_doc, show_list);
- if (show_func != NULL)
- set_cmd_sfunc (show, show_func);
+ full_show_doc, show_list);
+ show->show_value_func = show_func;
if (set_result != NULL)
*set_result = set;
*show_result = show;
}
-/* Add element named NAME to both the command SET_LIST and SHOW_LIST.
- CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
- setting. VAR is address of the variable being controlled by this
- command. SET_FUNC and SHOW_FUNC are the callback functions (if
- non-NULL). SET_DOC and SHOW_DOC are the documentation strings. */
+/* Add element named NAME to command list LIST (the list for set or
+ some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
+ of strings which may follow NAME. VAR is address of the variable
+ which will contain the matching string (from ENUMLIST). */
void
-add_setshow_cmd (char *name,
- enum command_class class,
- var_types var_type, void *var,
- char *set_doc, char *show_doc,
- cmd_sfunc_ftype *set_func, cmd_sfunc_ftype *show_func,
- struct cmd_list_element **set_list,
- struct cmd_list_element **show_list)
-{
- add_setshow_cmd_full (name, class, var_type, var, set_doc, show_doc,
- set_func, show_func, set_list, show_list,
- NULL, NULL);
-}
-
-struct cmd_list_element *
-add_set_cmd (char *name,
- enum command_class class,
- var_types var_type,
- void *var,
- char *doc,
- struct cmd_list_element **list)
-{
- return add_set_or_show_cmd (name, set_cmd, class, var_type, var, doc, list);
-}
-
-/* Add element named NAME to command list LIST (the list for set
- or some sublist thereof).
- CLASS is as in add_cmd.
- ENUMLIST is a list of strings which may follow NAME.
- VAR is address of the variable which will contain the matching string
- (from ENUMLIST).
- DOC is the documentation string. */
-
-struct cmd_list_element *
-add_set_enum_cmd (char *name,
- enum command_class class,
- const char *enumlist[],
- const char **var,
- char *doc,
- struct cmd_list_element **list)
+add_setshow_enum_cmd (char *name,
+ enum command_class class,
+ const char *enumlist[],
+ const char **var,
+ const char *set_doc,
+ const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
{
- struct cmd_list_element *c
- = add_set_cmd (name, class, var_enum, var, doc, list);
+ struct cmd_list_element *c;
+ add_setshow_cmd_full (name, class, var_enum, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ &c, NULL);
c->enums = enumlist;
-
- return c;
}
/* Add an auto-boolean command named NAME to both the set and show
add_setshow_auto_boolean_cmd (char *name,
enum command_class class,
enum auto_boolean *var,
- char *set_doc, char *show_doc,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
cmd_sfunc_ftype *set_func,
- cmd_sfunc_ftype *show_func,
+ show_value_ftype *show_func,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list)
{
static const char *auto_boolean_enums[] = { "on", "off", "auto", NULL };
struct cmd_list_element *c;
add_setshow_cmd_full (name, class, var_auto_boolean, var,
- set_doc, show_doc, set_func, show_func,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
set_list, show_list,
&c, NULL);
c->enums = auto_boolean_enums;
/* 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_DOR are the documentation strings. */
+ value. SET_DOC and SHOW_DOC are the documentation strings. */
void
-add_setshow_boolean_cmd (char *name,
- enum command_class class,
- int *var, char *set_doc, char *show_doc,
+add_setshow_boolean_cmd (char *name, enum command_class class, int *var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
cmd_sfunc_ftype *set_func,
- cmd_sfunc_ftype *show_func,
+ show_value_ftype *show_func,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list)
{
static const char *boolean_enums[] = { "on", "off", NULL };
struct cmd_list_element *c;
add_setshow_cmd_full (name, class, var_boolean, var,
- set_doc, show_doc,
+ set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list,
&c, NULL);
c->enums = boolean_enums;
}
-/* Where SETCMD has already been added, add the corresponding show
- command to LIST and return a pointer to the added command (not
- necessarily the head of LIST). */
-/* NOTE: cagney/2002-03-17: The original version of add_show_from_set
- used memcpy() to clone `set' into `show'. This meant that in
- addition to all the needed fields (var, name, et.al.) some
- unnecessary fields were copied (namely the callback function). The
- function explictly copies relevant fields. For a `set' and `show'
- command to share the same callback, the caller must set both
- explicitly. */
-struct cmd_list_element *
-add_show_from_set (struct cmd_list_element *setcmd,
- struct cmd_list_element **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,
+ char **var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
+{
+ struct cmd_list_element *set_result;
+ add_setshow_cmd_full (name, class, var_filename, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ &set_result, NULL);
+ set_cmd_completer (set_result, filename_completer);
+}
+
+/* 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,
+ char **var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
+{
+ add_setshow_cmd_full (name, class, var_string, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ NULL, NULL);
+}
+
+/* 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_noescape_cmd (char *name, enum command_class class,
+ char **var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
+{
+ add_setshow_cmd_full (name, class, var_string_noescape, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ NULL, NULL);
+}
+
+/* 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,
+ char **var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
{
- char *doc;
- const static char setstring[] = "Set ";
+ struct cmd_list_element *set_result;
+
+ add_setshow_cmd_full (name, class, var_optional_filename, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ &set_result, NULL);
+
+ set_cmd_completer (set_result, filename_completer);
- /* Create a doc string by replacing "Set " at the start of the
- `set'' command's doco with "Show ". */
- gdb_assert (strncmp (setcmd->doc, setstring, sizeof (setstring) - 1) == 0);
- doc = concat ("Show ", setcmd->doc + sizeof (setstring) - 1, NULL);
+}
- /* Insert the basic command. */
- return add_set_or_show_cmd (setcmd->name, show_cmd, setcmd->class,
- setcmd->var_type, setcmd->var, doc, list);
+/* 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. */
+void
+add_setshow_integer_cmd (char *name, enum command_class class,
+ int *var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
+{
+ add_setshow_cmd_full (name, class, var_integer, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ NULL, NULL);
+}
+
+/* Add element named NAME to both the set and show command LISTs (the
+ list for set/show or some sublist thereof). CLASS is as in
+ add_cmd. VAR is address of the variable which will contain the
+ value. SET_DOC and SHOW_DOC are the documentation strings. */
+void
+add_setshow_uinteger_cmd (char *name, enum command_class class,
+ unsigned int *var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
+{
+ add_setshow_cmd_full (name, class, var_uinteger, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ NULL, NULL);
}
-/* Remove the command named NAME from the command list. */
+/* 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. */
+void
+add_setshow_zinteger_cmd (char *name, enum command_class class,
+ int *var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
+{
+ add_setshow_cmd_full (name, class, var_zinteger, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ NULL, NULL);
+}
+/* Add element named NAME to both the set and show command LISTs (the
+ list for set/show or some sublist thereof). CLASS is as in
+ add_cmd. VAR is address of the variable which will contain the
+ value. SET_DOC and SHOW_DOC are the documentation strings. */
void
-delete_cmd (char *name, struct cmd_list_element **list)
+add_setshow_zuinteger_cmd (char *name, enum command_class class,
+ unsigned int *var,
+ const char *set_doc, const char *show_doc,
+ const char *help_doc,
+ cmd_sfunc_ftype *set_func,
+ show_value_ftype *show_func,
+ struct cmd_list_element **set_list,
+ struct cmd_list_element **show_list)
+{
+ add_setshow_cmd_full (name, class, var_zuinteger, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ NULL, NULL);
+}
+
+/* Remove the command named NAME from the command list. Return the
+ list commands which were aliased to the deleted command. If the
+ command had no aliases, return NULL. The various *HOOKs are set to
+ the pre- and post-hook commands for the deleted command. If the
+ command does not have a hook, the corresponding out parameter is
+ set to NULL. */
+
+static struct cmd_list_element *
+delete_cmd (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)
{
- register struct cmd_list_element *c;
- struct cmd_list_element *p;
+ struct cmd_list_element *iter;
+ struct cmd_list_element **previous_chain_ptr;
+ struct cmd_list_element *aliases = NULL;
- while (*list && STREQ ((*list)->name, name))
+ *prehook = NULL;
+ *prehookee = NULL;
+ *posthook = NULL;
+ *posthookee = NULL;
+ previous_chain_ptr = list;
+
+ for (iter = *previous_chain_ptr; iter; iter = *previous_chain_ptr)
{
- if ((*list)->hookee_pre)
- (*list)->hookee_pre->hook_pre = 0; /* Hook slips out of its mouth */
- if ((*list)->hookee_post)
- (*list)->hookee_post->hook_post = 0; /* Hook slips out of its bottom */
- p = (*list)->next;
- xfree (* list);
- *list = p;
+ if (strcmp (iter->name, name) == 0)
+ {
+ if (iter->destroyer)
+ iter->destroyer (iter, iter->context);
+ if (iter->hookee_pre)
+ iter->hookee_pre->hook_pre = 0;
+ *prehook = iter->hook_pre;
+ *prehookee = iter->hookee_pre;
+ if (iter->hookee_post)
+ iter->hookee_post->hook_post = 0;
+ *posthook = iter->hook_post;
+ *posthookee = iter->hookee_post;
+
+ /* Update the link. */
+ *previous_chain_ptr = iter->next;
+
+ aliases = iter->aliases;
+
+ /* If this command was an alias, remove it from the list of
+ aliases. */
+ if (iter->cmd_pointer)
+ {
+ struct cmd_list_element **prevp = &iter->cmd_pointer->aliases;
+ struct cmd_list_element *a = *prevp;
+
+ while (a != iter)
+ {
+ prevp = &a->alias_chain;
+ a = *prevp;
+ }
+ *prevp = iter->alias_chain;
+ }
+
+ xfree (iter);
+
+ /* We won't see another command with the same name. */
+ break;
+ }
+ else
+ previous_chain_ptr = &iter->next;
}
- if (*list)
- for (c = *list; c->next;)
- {
- if (STREQ (c->next->name, name))
- {
- if (c->next->hookee_pre)
- c->next->hookee_pre->hook_pre = 0; /* hooked cmd gets away. */
- if (c->next->hookee_post)
- c->next->hookee_post->hook_post = 0; /* remove post hook */
- /* :( no fishing metaphore */
- p = c->next->next;
- xfree (c->next);
- c->next = p;
- }
- else
- c = c->next;
- }
+ return aliases;
}
\f
/* Shorthands to the commands above. */
apropos_cmd (struct ui_file *stream, struct cmd_list_element *commandlist,
struct re_pattern_buffer *regex, char *prefix)
{
- register struct cmd_list_element *c;
- int returnvalue=1; /*Needed to avoid double printing*/
+ struct cmd_list_element *c;
+ int returnvalue;
/* Walk through the commands */
for (c=commandlist;c;c=c->next)
{
+ returnvalue = -1; /*Needed to avoid double printing*/
if (c->name != NULL)
{
/* Try to match against the name*/
returnvalue=re_search(regex,c->name,strlen(c->name),0,strlen(c->name),NULL);
if (returnvalue >= 0)
{
- /* Stolen from help_cmd_list. We don't directly use
- * help_cmd_list because it doesn't let us print out
- * single commands
- */
- fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
- print_doc_line (stream, c->doc);
- fputs_filtered ("\n", stream);
- returnvalue=0; /*Set this so we don't print it again.*/
+ print_help_for_command (c, prefix,
+ 0 /* don't recurse */, stream);
}
}
- if (c->doc != NULL && returnvalue != 0)
+ if (c->doc != NULL && returnvalue < 0)
{
/* Try to match against documentation */
if (re_search(regex,c->doc,strlen(c->doc),0,strlen(c->doc),NULL) >=0)
{
- /* Stolen from help_cmd_list. We don't directly use
- * help_cmd_list because it doesn't let us print out
- * single commands
- */
- fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
- print_doc_line (stream, c->doc);
- fputs_filtered ("\n", stream);
+ print_help_for_command (c, prefix,
+ 0 /* don't recurse */, stream);
}
}
- /* Check if this command has subcommands */
- if (c->prefixlist != NULL)
+ /* Check if this command has subcommands and is not an abbreviation.
+ We skip listing subcommands of abbreviations in order to avoid
+ duplicates in the output.
+ */
+ if (c->prefixlist != NULL && !c->abbrev_flag)
{
/* Recursively call ourselves on the subcommand list,
passing the right prefix in.
"\nThis command has a hook (or hooks) defined:\n");
if (c->hook_pre)
- fprintf_filtered (stream,
+ fprintf_filtered (stream,
"\tThis command is run after : %s (pre hook)\n",
c->hook_pre->name);
if (c->hook_post)
- fprintf_filtered (stream,
+ fprintf_filtered (stream,
"\tThis command is run before : %s (post hook)\n",
c->hook_post->name);
}
cmdtype1);
wrap_here ("");
fprintf_filtered (stream, "that class.");
+
+ fprintf_filtered (stream, "\n\
+Type \"help all\" for the list of all commands.");
}
fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ",
fputs_filtered ("full ", stream);
wrap_here ("");
fputs_filtered ("documentation.\n", stream);
+ fputs_filtered ("Type \"apropos word\" to search "
+ "for commands related to \"word\".\n", stream);
fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
stream);
}
{
struct cmd_list_element *c;
extern struct cmd_list_element *cmdlist;
+ int seen_unclassified = 0;
for (c = cmdlist; c; c = c->next)
{
if (c->abbrev_flag)
continue;
- /* If this is a prefix command, print it's subcommands */
- if (c->prefixlist)
- help_cmd_list (*c->prefixlist, all_commands, c->prefixname, 0, stream);
-
/* If this is a class name, print all of the commands in the class */
- else if (c->func == NULL)
- help_cmd_list (cmdlist, c->class, "", 0, stream);
+
+ if (c->func == NULL)
+ {
+ fprintf_filtered (stream, "\nCommand class: %s\n\n", c->name);
+ help_cmd_list (cmdlist, c->class, "", 1, stream);
+ }
+ }
+
+ /* While it's expected that all commands are in some class,
+ as a safety measure, we'll print commands outside of any
+ class at the end. */
+
+ for (c = cmdlist; c; c = c->next)
+ {
+ if (c->abbrev_flag)
+ continue;
+
+ if (c->class == no_class)
+ {
+ if (!seen_unclassified)
+ {
+ fprintf_filtered (stream, "\nUnclassified commands\n\n");
+ seen_unclassified = 1;
+ }
+ print_help_for_command (c, "", 1, stream);
+ }
}
+
}
/* Print only the first line of STR on STREAM. */
{
static char *line_buffer = 0;
static int line_size;
- register char *p;
+ char *p;
if (!line_buffer)
{
ui_out_text (uiout, line_buffer);
}
+/* Print one-line help for command C.
+ 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)
+{
+ fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
+ print_doc_line (stream, c->doc);
+ fputs_filtered ("\n", stream);
+
+ if (recurse
+ && c->prefixlist != 0
+ && c->abbrev_flag == 0)
+ /* Subcommands of a prefix command typically have 'all_commands'
+ as class. If we pass CLASS to recursive invocation,
+ most often we won't see anything. */
+ help_cmd_list (*c->prefixlist, all_commands, c->prefixname, 1, stream);
+}
+
/*
* Implement a help command on command list LIST.
* RECURSE should be non-zero if this should be done recursively on
help_cmd_list (struct cmd_list_element *list, enum command_class class,
char *prefix, int recurse, struct ui_file *stream)
{
- register struct cmd_list_element *c;
+ 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)))
{
- fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
- print_doc_line (stream, c->doc);
- fputs_filtered ("\n", stream);
+ print_help_for_command (c, prefix, recurse, stream);
}
- if (recurse
- && c->prefixlist != 0
- && c->abbrev_flag == 0)
- help_cmd_list (*c->prefixlist, class, c->prefixname, 1, stream);
+ else if (c->abbrev_flag == 0 && recurse
+ && class == class_user && c->prefixlist != NULL)
+ /* User-defined commands may be subcommands. */
+ help_cmd_list (*c->prefixlist, class, c->prefixname, recurse, stream);
}
}
\f
return found;
}
+static int
+find_command_name_length (const char *text)
+{
+ const char *p = text;
+
+ /* Treating underscores as part of command words is important
+ so that "set args_foo()" doesn't get interpreted as
+ "set args _foo()". */
+ /* 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++;
+
+ return p - text;
+}
+
/* This routine takes a line of TEXT and a CLIST in which to start the
lookup. When it returns it will have incremented the text pointer past
the section of text it matched, set *RESULT_LIST to point to the list in
lookup_cmd_1 (char **text, struct cmd_list_element *clist,
struct cmd_list_element **result_list, int ignore_help_classes)
{
- char *p, *command;
+ char *command;
int len, tmp, nfound;
struct cmd_list_element *found, *c;
char *line = *text;
while (**text == ' ' || **text == '\t')
(*text)++;
- /* Treating underscores as part of command words is important
- so that "set args_foo()" doesn't get interpreted as
- "set args _foo()". */
- /* NOTE: cagney/2003-02-13 The `tui_active' was previously
- `tui_version'. */
- for (p = *text;
- *p && (isalnum (*p) || *p == '-' || *p == '_' ||
- (tui_active &&
- (*p == '+' || *p == '<' || *p == '>' || *p == '$')) ||
- (xdb_commands && (*p == '!' || *p == '/' || *p == '?')));
- p++)
- ;
+ /* Identify the name of the command. */
+ len = find_command_name_length (*text);
/* If nothing but whitespace, return 0. */
- if (p == *text)
+ if (len == 0)
return 0;
- len = p - *text;
-
/* *text and p now bracket the first command word to lookup (and
it's length is len). We copy this into a local temporary */
command = (char *) alloca (len + 1);
- for (tmp = 0; tmp < len; tmp++)
- {
- char x = (*text)[tmp];
- command[tmp] = x;
- }
+ memcpy (command, *text, len);
command[len] = '\0';
/* Look it up. */
/* We've matched something on this list. Move text pointer forward. */
- *text = p;
+ *text += len;
if (found->cmd_pointer)
{
flags */
if (found->flags & DEPRECATED_WARN_USER)
- deprecated_cmd_warning (&line);
+ deprecated_cmd_warning (&line);
found = found->cmd_pointer;
}
/* If we found a prefix command, keep looking. */
static void
undef_cmd_error (char *cmdtype, char *q)
{
- error ("Undefined %scommand: \"%s\". Try \"help%s%.*s\".",
+ error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
cmdtype,
q,
*cmdtype ? " " : "",
int allow_unknown, int ignore_help_classes)
{
struct cmd_list_element *last_list = 0;
- struct cmd_list_element *c =
- lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
+ struct cmd_list_element *c;
/* Note: Do not remove trailing whitespace here because this
would be wrong for complete_command. Jim Kingdon */
+ if (!*line)
+ error (_("Lack of needed %scommand"), cmdtype);
+
+ c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
+
if (!c)
{
if (!allow_unknown)
{
- if (!*line)
- error ("Lack of needed %scommand", cmdtype);
- else
- {
- char *p = *line, *q;
+ char *q;
+ int len = find_command_name_length (*line);
- while (isalnum (*p) || *p == '-')
- p++;
-
- q = (char *) alloca (p - *line + 1);
- strncpy (q, *line, p - *line);
- q[p - *line] = '\0';
- undef_cmd_error (cmdtype, q);
- }
+ q = (char *) alloca (len + 1);
+ strncpy (q, *line, len);
+ q[len] = '\0';
+ undef_cmd_error (cmdtype, q);
}
else
return 0;
break;
}
}
- error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype,
+ error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype,
*line, ambbuf);
return 0; /* lint */
}
struct cmd_list_element *cmd = NULL;
struct cmd_list_element *c;
char *type;
-
+
if (!lookup_cmd_composition (*text, &alias, &prefix_cmd, &cmd))
/* return if text doesn't evaluate to a command */
return;
struct cmd_list_element **prefix_cmd,
struct cmd_list_element **cmd)
{
- char *p, *command;
+ char *command;
int len, tmp, nfound;
struct cmd_list_element *cur_list;
struct cmd_list_element *prev_cmd;
while (*text == ' ' || *text == '\t')
(text)++;
- /* Treating underscores as part of command words is important
- so that "set args_foo()" doesn't get interpreted as
- "set args _foo()". */
- /* NOTE: cagney/2003-02-13 The `tui_active' was previously
- `tui_version'. */
- for (p = text;
- *p && (isalnum (*p) || *p == '-' || *p == '_' ||
- (tui_active &&
- (*p == '+' || *p == '<' || *p == '>' || *p == '$')) ||
- (xdb_commands && (*p == '!' || *p == '/' || *p == '?')));
- p++)
- ;
+ /* Identify the name of the command. */
+ len = find_command_name_length (text);
/* If nothing but whitespace, return. */
- if (p == text)
- return 0;
-
- len = p - text;
+ if (len == 0)
+ return 0;
- /* text and p now bracket the first command word to lookup (and
+ /* text is the start of the first command word to lookup (and
it's length is len). We copy this into a local temporary */
command = (char *) alloca (len + 1);
- for (tmp = 0; tmp < len; tmp++)
- {
- char x = text[tmp];
- command[tmp] = x;
- }
+ memcpy (command, text, len);
command[len] = '\0';
/* Look it up. */
else
return 1;
- text = p;
+ text += len;
}
}
if (cmd_func_p (cmd))
(*cmd->func) (cmd, args, from_tty);
else
- error ("Invalid command");
+ error (_("Invalid command"));
}
-
-