/* 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
+ 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 *);
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_cfunc (struct cmd_list_element *cmd,
- void (*cfunc) (char *args, int from_tty))
+set_cmd_cfunc (struct cmd_list_element *cmd, cmd_cfunc_ftype *cfunc)
{
if (cfunc == NULL)
cmd->func = NULL;
}
void
-set_cmd_sfunc (struct cmd_list_element *cmd,
- void (*sfunc) (char *args, int from_tty,
- struct cmd_list_element * c))
+set_cmd_sfunc (struct cmd_list_element *cmd, cmd_sfunc_ftype *sfunc)
{
if (sfunc == NULL)
cmd->func = NULL;
return cmd->func == do_cfunc && cmd->function.cfunc == cfunc;
}
+void
+set_cmd_context (struct cmd_list_element *cmd, void *context)
+{
+ cmd->context = context;
+}
+
+void *
+get_cmd_context (struct cmd_list_element *cmd)
+{
+ return cmd->context;
+}
+
+enum cmd_types
+cmd_type (struct cmd_list_element *cmd)
+{
+ return cmd->type;
+}
+
+void
+set_cmd_completer (struct cmd_list_element *cmd,
+ char **(*completer) (char *text, char *word))
+{
+ cmd->completer = completer; /* Ok. */
+}
+
/* Add element named NAME.
CLASS is the top level category into which commands are broken down
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;
c->name = name;
c->class = class;
set_cmd_cfunc (c, fun);
+ set_cmd_context (c, NULL);
c->doc = doc;
c->flags = 0;
c->replacement = NULL;
c->prefixname = NULL;
c->allow_unknown = 0;
c->abbrev_flag = 0;
- c->completer = make_symbol_completion_list;
+ set_cmd_completer (c, make_symbol_completion_list);
c->type = not_set_cmd;
c->var = NULL;
c->var_type = var_boolean;
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);
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;
{
}
-/* Add element named NAME to command list LIST (the list for set
+/* Add element named NAME to command list LIST (the list for set/show
or some sublist thereof).
+ TYPE is set_cmd or show_cmd.
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.
DOC is the documentation string. */
-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)
+static struct cmd_list_element *
+add_set_or_show_cmd (char *name,
+ enum cmd_types type,
+ enum command_class class,
+ var_types var_type,
+ void *var,
+ char *doc,
+ struct cmd_list_element **list)
{
struct cmd_list_element *c = add_cmd (name, class, NULL, doc, list);
-
- c->type = set_cmd;
+ gdb_assert (type == set_cmd || type == show_cmd);
+ c->type = type;
c->var_type = var_type;
c->var = var;
/* This needs to be something besides NULL so that this isn't
return c;
}
-/* 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. */
+/* 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, 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. */
-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)
+static void
+add_setshow_cmd_full (char *name,
+ enum command_class class,
+ var_types var_type, void *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,
+ struct cmd_list_element **show_result)
{
- struct cmd_list_element *c
- = add_set_cmd (name, class, var_enum, var, doc, list);
- c->enums = enumlist;
+ struct cmd_list_element *set;
+ struct cmd_list_element *show;
+ char *full_set_doc;
+ char *full_show_doc;
- return c;
+ 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,
+ 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,
+ full_show_doc, show_list);
+ show->show_value_func = show_func;
+
+ if (set_result != NULL)
+ *set_result = set;
+ if (show_result != NULL)
+ *show_result = show;
}
-/* Add element named NAME to command list LIST (the list for set
- or some sublist thereof).
- CLASS is as in add_cmd.
- VAR is address of the variable which will contain the value.
- DOC is the documentation string. */
struct cmd_list_element *
-add_set_auto_boolean_cmd (char *name,
- enum command_class class,
- enum cmd_auto_boolean *var,
- char *doc,
- struct cmd_list_element **list)
+deprecated_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). */
+
+void
+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_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;
+}
+
+/* Add an auto-boolean command named NAME to both the set and show
+ command list lists. CLASS is as in add_cmd. VAR is address of the
+ 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,
+ enum auto_boolean *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)
{
static const char *auto_boolean_enums[] = { "on", "off", "auto", NULL };
struct cmd_list_element *c;
- c = add_set_cmd (name, class, var_auto_boolean, var, doc, list);
+ add_setshow_cmd_full (name, class, var_auto_boolean, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ &c, NULL);
c->enums = auto_boolean_enums;
- return c;
}
-/* Add element named NAME to command list LIST (the list for set
- or some sublist thereof).
- CLASS is as in add_cmd.
- VAR is address of the variable which will contain the value.
- DOC is the documentation string. */
-struct cmd_list_element *
-add_set_boolean_cmd (char *name,
- enum command_class class,
- int *var,
- char *doc,
- 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). 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_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,
+ 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;
- c = add_set_cmd (name, class, var_boolean, var, doc, list);
+ add_setshow_cmd_full (name, class, var_boolean, var,
+ set_doc, show_doc, help_doc,
+ set_func, show_func,
+ set_list, show_list,
+ &c, NULL);
c->enums = boolean_enums;
- return c;
}
-/* 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). */
-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 *showcmd =
- (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
- struct cmd_list_element *p;
+ 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);
+}
- memcpy (showcmd, setcmd, sizeof (struct cmd_list_element));
- delete_cmd (showcmd->name, list);
- showcmd->type = show_cmd;
+/* 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);
+}
- /* Replace "set " at start of docstring with "show ". */
- if (setcmd->doc[0] == 'S' && setcmd->doc[1] == 'e'
- && setcmd->doc[2] == 't' && setcmd->doc[3] == ' ')
- showcmd->doc = concat ("Show ", setcmd->doc + 4, NULL);
- else
- fprintf_unfiltered (gdb_stderr, "GDB internal error: Bad docstring for set command\n");
+/* 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);
+}
- if (*list == NULL || strcmp ((*list)->name, showcmd->name) >= 0)
- {
- showcmd->next = *list;
- *list = showcmd;
- }
- else
- {
- p = *list;
- while (p->next && strcmp (p->next->name, showcmd->name) <= 0)
- {
- p = p->next;
- }
- showcmd->next = p->next;
- p->next = showcmd;
- }
+/* 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)
+{
+ add_setshow_cmd_full (name, class, var_optional_filename, 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_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);
+}
- return showcmd;
+/* 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);
+}
+
+/* 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);
}
/* Remove the command named NAME from the command list. */
void
delete_cmd (char *name, struct cmd_list_element **list)
{
- register struct cmd_list_element *c;
+ struct cmd_list_element *c;
struct cmd_list_element *p;
- while (*list && STREQ ((*list)->name, name))
+ while (*list && strcmp ((*list)->name, name) == 0)
{
if ((*list)->hookee_pre)
(*list)->hookee_pre->hook_pre = 0; /* Hook slips out of its mouth */
if (*list)
for (c = *list; c->next;)
{
- if (STREQ (c->next->name, name))
+ if (strcmp (c->next->name, name) == 0)
{
if (c->next->hookee_pre)
c->next->hookee_pre->hook_pre = 0; /* hooked cmd gets away. */
apropos_cmd (struct ui_file *stream, struct cmd_list_element *commandlist,
struct re_pattern_buffer *regex, char *prefix)
{
- register struct cmd_list_element *c;
+ struct cmd_list_element *c;
int returnvalue=1; /*Needed to avoid double printing*/
/* Walk through the commands */
for (c=commandlist;c;c=c->next)
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)
/* 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 */
help_cmd_list (list, class, cmdtype, (int) class >= 0, stream);
if (class == all_classes)
- fprintf_filtered (stream, "\n\
-Type \"help%s\" followed by a class name for a list of commands in that class.",
- cmdtype1);
+ {
+ fprintf_filtered (stream, "\n\
+Type \"help%s\" followed by a class name for a list of commands in ",
+ cmdtype1);
+ wrap_here ("");
+ fprintf_filtered (stream, "that class.");
+
+ fprintf_filtered (stream, "\n\
+Type \"help all\" for the list of all commands.");
+ }
- fprintf_filtered (stream, "\n\
-Type \"help%s\" followed by %scommand name for full documentation.\n\
-Command name abbreviations are allowed if unambiguous.\n",
+ fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ",
cmdtype1, cmdtype2);
+ wrap_here ("");
+ fputs_filtered ("for ", stream);
+ wrap_here ("");
+ 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);
}
static void
{
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);
}
}
\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()". */
- for (p = *text;
- *p && (isalnum (*p) || *p == '-' || *p == '_' ||
- (tui_version &&
- (*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 */
/* We've matched something on this list. Move text pointer forward. */
- *text = p;
+ *text += len;
if (found->cmd_pointer)
{
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 ? " " : "",
- strlen (cmdtype) - 1,
+ (int) strlen (cmdtype) - 1,
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()". */
- for (p = text;
- *p && (isalnum (*p) || *p == '-' || *p == '_' ||
- (tui_version &&
- (*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);
else
return 1;
- text = p;
+ text += len;
}
}
return matchlist;
}
+
+/* check function pointer */
+int
+cmd_func_p (struct cmd_list_element *cmd)
+{
+ return (cmd->func != NULL);
+}
+
+
+/* call the command function */
+void
+cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
+{
+ if (cmd_func_p (cmd))
+ (*cmd->func) (cmd, args, from_tty);
+ else
+ error (_("Invalid command"));
+}
+
+
projects / thirdparty / binutils-gdb.git / blobdiff