1 /* Handle lists of commands, their decoding and documentation, for GDB.
3 Copyright (c) 1986, 1989, 1990, 1991, 1998, 2000, 2001, 2002, 2004, 2007,
4 2008 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_regex.h"
23 #include "gdb_string.h"
24 #include "completer.h"
27 #include "cli/cli-cmds.h"
28 #include "cli/cli-decode.h"
31 #include "tui/tui.h" /* For tui_active et.al. */
34 #include "gdb_assert.h"
36 /* Prototypes for local functions */
38 static void undef_cmd_error (char *, char *);
40 static struct cmd_list_element *find_cmd (char *command,
42 struct cmd_list_element *clist,
43 int ignore_help_classes,
46 static void help_all (struct ui_file *stream);
49 print_help_for_command (struct cmd_list_element *c, char *prefix, int recurse,
50 struct ui_file *stream);
53 /* Set the callback function for the specified command. For each both
54 the commands callback and func() are set. The latter set to a
55 bounce function (unless cfunc / sfunc is NULL that is). */
58 do_cfunc (struct cmd_list_element *c, char *args, int from_tty)
60 c->function.cfunc (args, from_tty); /* Ok. */
64 set_cmd_cfunc (struct cmd_list_element *cmd, cmd_cfunc_ftype *cfunc)
70 cmd->function.cfunc = cfunc; /* Ok. */
74 do_sfunc (struct cmd_list_element *c, char *args, int from_tty)
76 c->function.sfunc (args, from_tty, c); /* Ok. */
80 set_cmd_sfunc (struct cmd_list_element *cmd, cmd_sfunc_ftype *sfunc)
86 cmd->function.sfunc = sfunc; /* Ok. */
90 cmd_cfunc_eq (struct cmd_list_element *cmd,
91 void (*cfunc) (char *args, int from_tty))
93 return cmd->func == do_cfunc && cmd->function.cfunc == cfunc;
97 set_cmd_context (struct cmd_list_element *cmd, void *context)
99 cmd->context = context;
103 get_cmd_context (struct cmd_list_element *cmd)
109 set_cmd_async_ok (struct cmd_list_element *cmd)
111 cmd->flags |= CMD_ASYNC_OK;
115 get_cmd_async_ok (struct cmd_list_element *cmd)
117 return cmd->flags & CMD_ASYNC_OK;
121 cmd_type (struct cmd_list_element *cmd)
127 set_cmd_completer (struct cmd_list_element *cmd,
128 char **(*completer) (char *text, char *word))
130 cmd->completer = completer; /* Ok. */
134 /* Add element named NAME.
135 CLASS is the top level category into which commands are broken down
137 FUN should be the function to execute the command;
138 it will get a character string as argument, with leading
139 and trailing blanks already eliminated.
141 DOC is a documentation string for the command.
142 Its first line should be a complete sentence.
143 It should start with ? for a command that is an abbreviation
144 or with * for a command that most users don't need to know about.
146 Add this command to command list *LIST.
148 Returns a pointer to the added command (not necessarily the head
151 struct cmd_list_element *
152 add_cmd (char *name, enum command_class class, void (*fun) (char *, int),
153 char *doc, struct cmd_list_element **list)
155 struct cmd_list_element *c
156 = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
157 struct cmd_list_element *p;
159 delete_cmd (name, list);
161 if (*list == NULL || strcmp ((*list)->name, name) >= 0)
169 while (p->next && strcmp (p->next->name, name) <= 0)
179 set_cmd_cfunc (c, fun);
180 set_cmd_context (c, NULL);
183 c->replacement = NULL;
184 c->pre_show_hook = NULL;
188 c->prefixlist = NULL;
189 c->prefixname = NULL;
190 c->allow_unknown = 0;
192 set_cmd_completer (c, make_symbol_completion_list);
193 c->type = not_set_cmd;
195 c->var_type = var_boolean;
197 c->user_commands = NULL;
198 c->hookee_pre = NULL;
199 c->hookee_post = NULL;
200 c->cmd_pointer = NULL;
205 /* Deprecates a command CMD.
206 REPLACEMENT is the name of the command which should be used in place
207 of this command, or NULL if no such command exists.
209 This function does not check to see if command REPLACEMENT exists
210 since gdb may not have gotten around to adding REPLACEMENT when this
213 Returns a pointer to the deprecated command. */
215 struct cmd_list_element *
216 deprecate_cmd (struct cmd_list_element *cmd, char *replacement)
218 cmd->flags |= (CMD_DEPRECATED | DEPRECATED_WARN_USER);
220 if (replacement != NULL)
221 cmd->replacement = replacement;
223 cmd->replacement = NULL;
228 struct cmd_list_element *
229 add_alias_cmd (char *name, char *oldname, enum command_class class,
230 int abbrev_flag, struct cmd_list_element **list)
232 /* Must do this since lookup_cmd tries to side-effect its first arg */
234 struct cmd_list_element *old;
235 struct cmd_list_element *c;
236 copied_name = (char *) alloca (strlen (oldname) + 1);
237 strcpy (copied_name, oldname);
238 old = lookup_cmd (&copied_name, *list, "", 1, 1);
242 delete_cmd (name, list);
246 c = add_cmd (name, class, NULL, old->doc, list);
247 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
249 c->function = old->function;
250 c->prefixlist = old->prefixlist;
251 c->prefixname = old->prefixname;
252 c->allow_unknown = old->allow_unknown;
253 c->abbrev_flag = abbrev_flag;
254 c->cmd_pointer = old;
258 /* Like add_cmd but adds an element for a command prefix:
259 a name that should be followed by a subcommand to be looked up
260 in another command list. PREFIXLIST should be the address
261 of the variable containing that list. */
263 struct cmd_list_element *
264 add_prefix_cmd (char *name, enum command_class class, void (*fun) (char *, int),
265 char *doc, struct cmd_list_element **prefixlist,
266 char *prefixname, int allow_unknown,
267 struct cmd_list_element **list)
269 struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
270 c->prefixlist = prefixlist;
271 c->prefixname = prefixname;
272 c->allow_unknown = allow_unknown;
276 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
278 struct cmd_list_element *
279 add_abbrev_prefix_cmd (char *name, enum command_class class,
280 void (*fun) (char *, int), char *doc,
281 struct cmd_list_element **prefixlist, char *prefixname,
282 int allow_unknown, struct cmd_list_element **list)
284 struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
285 c->prefixlist = prefixlist;
286 c->prefixname = prefixname;
287 c->allow_unknown = allow_unknown;
292 /* This is an empty "cfunc". */
294 not_just_help_class_command (char *args, int from_tty)
298 /* This is an empty "sfunc". */
299 static void empty_sfunc (char *, int, struct cmd_list_element *);
302 empty_sfunc (char *args, int from_tty, struct cmd_list_element *c)
306 /* Add element named NAME to command list LIST (the list for set/show
307 or some sublist thereof).
308 TYPE is set_cmd or show_cmd.
309 CLASS is as in add_cmd.
310 VAR_TYPE is the kind of thing we are setting.
311 VAR is address of the variable being controlled by this command.
312 DOC is the documentation string. */
314 static struct cmd_list_element *
315 add_set_or_show_cmd (char *name,
317 enum command_class class,
321 struct cmd_list_element **list)
323 struct cmd_list_element *c = add_cmd (name, class, NULL, doc, list);
324 gdb_assert (type == set_cmd || type == show_cmd);
326 c->var_type = var_type;
328 /* This needs to be something besides NULL so that this isn't
329 treated as a help class. */
330 set_cmd_sfunc (c, empty_sfunc);
334 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
335 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
336 setting. VAR is address of the variable being controlled by this
337 command. SET_FUNC and SHOW_FUNC are the callback functions (if
338 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
339 strings. PRINT the format string to print the value. SET_RESULT
340 and SHOW_RESULT, if not NULL, are set to the resulting command
344 add_setshow_cmd_full (char *name,
345 enum command_class class,
346 var_types var_type, void *var,
347 const char *set_doc, const char *show_doc,
348 const char *help_doc,
349 cmd_sfunc_ftype *set_func,
350 show_value_ftype *show_func,
351 struct cmd_list_element **set_list,
352 struct cmd_list_element **show_list,
353 struct cmd_list_element **set_result,
354 struct cmd_list_element **show_result)
356 struct cmd_list_element *set;
357 struct cmd_list_element *show;
361 if (help_doc != NULL)
363 full_set_doc = xstrprintf ("%s\n%s", set_doc, help_doc);
364 full_show_doc = xstrprintf ("%s\n%s", show_doc, help_doc);
368 full_set_doc = xstrdup (set_doc);
369 full_show_doc = xstrdup (show_doc);
371 set = add_set_or_show_cmd (name, set_cmd, class, var_type, var,
372 full_set_doc, set_list);
373 if (set_func != NULL)
374 set_cmd_sfunc (set, set_func);
375 show = add_set_or_show_cmd (name, show_cmd, class, var_type, var,
376 full_show_doc, show_list);
377 show->show_value_func = show_func;
379 if (set_result != NULL)
381 if (show_result != NULL)
385 struct cmd_list_element *
386 deprecated_add_set_cmd (char *name,
387 enum command_class class,
391 struct cmd_list_element **list)
393 return add_set_or_show_cmd (name, set_cmd, class, var_type, var, doc, list);
396 /* Add element named NAME to command list LIST (the list for set or
397 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
398 of strings which may follow NAME. VAR is address of the variable
399 which will contain the matching string (from ENUMLIST). */
402 add_setshow_enum_cmd (char *name,
403 enum command_class class,
404 const char *enumlist[],
407 const char *show_doc,
408 const char *help_doc,
409 cmd_sfunc_ftype *set_func,
410 show_value_ftype *show_func,
411 struct cmd_list_element **set_list,
412 struct cmd_list_element **show_list)
414 struct cmd_list_element *c;
415 add_setshow_cmd_full (name, class, var_enum, var,
416 set_doc, show_doc, help_doc,
423 /* Add an auto-boolean command named NAME to both the set and show
424 command list lists. CLASS is as in add_cmd. VAR is address of the
425 variable which will contain the value. DOC is the documentation
426 string. FUNC is the corresponding callback. */
428 add_setshow_auto_boolean_cmd (char *name,
429 enum command_class class,
430 enum auto_boolean *var,
431 const char *set_doc, const char *show_doc,
432 const char *help_doc,
433 cmd_sfunc_ftype *set_func,
434 show_value_ftype *show_func,
435 struct cmd_list_element **set_list,
436 struct cmd_list_element **show_list)
438 static const char *auto_boolean_enums[] = { "on", "off", "auto", NULL };
439 struct cmd_list_element *c;
440 add_setshow_cmd_full (name, class, var_auto_boolean, var,
441 set_doc, show_doc, help_doc,
445 c->enums = auto_boolean_enums;
448 /* Add element named NAME to both the set and show command LISTs (the
449 list for set/show or some sublist thereof). CLASS is as in
450 add_cmd. VAR is address of the variable which will contain the
451 value. SET_DOC and SHOW_DOC are the documentation strings. */
453 add_setshow_boolean_cmd (char *name, enum command_class class, int *var,
454 const char *set_doc, const char *show_doc,
455 const char *help_doc,
456 cmd_sfunc_ftype *set_func,
457 show_value_ftype *show_func,
458 struct cmd_list_element **set_list,
459 struct cmd_list_element **show_list)
461 static const char *boolean_enums[] = { "on", "off", NULL };
462 struct cmd_list_element *c;
463 add_setshow_cmd_full (name, class, var_boolean, var,
464 set_doc, show_doc, help_doc,
468 c->enums = boolean_enums;
471 /* Add element named NAME to both the set and show command LISTs (the
472 list for set/show or some sublist thereof). */
474 add_setshow_filename_cmd (char *name, enum command_class class,
476 const char *set_doc, const char *show_doc,
477 const char *help_doc,
478 cmd_sfunc_ftype *set_func,
479 show_value_ftype *show_func,
480 struct cmd_list_element **set_list,
481 struct cmd_list_element **show_list)
483 struct cmd_list_element *set_result;
484 add_setshow_cmd_full (name, class, var_filename, var,
485 set_doc, show_doc, help_doc,
489 set_cmd_completer (set_result, filename_completer);
492 /* Add element named NAME to both the set and show command LISTs (the
493 list for set/show or some sublist thereof). */
495 add_setshow_string_cmd (char *name, enum command_class class,
497 const char *set_doc, const char *show_doc,
498 const char *help_doc,
499 cmd_sfunc_ftype *set_func,
500 show_value_ftype *show_func,
501 struct cmd_list_element **set_list,
502 struct cmd_list_element **show_list)
504 add_setshow_cmd_full (name, class, var_string, var,
505 set_doc, show_doc, help_doc,
511 /* Add element named NAME to both the set and show command LISTs (the
512 list for set/show or some sublist thereof). */
514 add_setshow_string_noescape_cmd (char *name, enum command_class class,
516 const char *set_doc, const char *show_doc,
517 const char *help_doc,
518 cmd_sfunc_ftype *set_func,
519 show_value_ftype *show_func,
520 struct cmd_list_element **set_list,
521 struct cmd_list_element **show_list)
523 add_setshow_cmd_full (name, class, var_string_noescape, var,
524 set_doc, show_doc, help_doc,
530 /* Add element named NAME to both the set and show command LISTs (the
531 list for set/show or some sublist thereof). */
533 add_setshow_optional_filename_cmd (char *name, enum command_class class,
535 const char *set_doc, const char *show_doc,
536 const char *help_doc,
537 cmd_sfunc_ftype *set_func,
538 show_value_ftype *show_func,
539 struct cmd_list_element **set_list,
540 struct cmd_list_element **show_list)
542 add_setshow_cmd_full (name, class, var_optional_filename, var,
543 set_doc, show_doc, help_doc,
549 /* Add element named NAME to both the set and show command LISTs (the
550 list for set/show or some sublist thereof). CLASS is as in
551 add_cmd. VAR is address of the variable which will contain the
552 value. SET_DOC and SHOW_DOC are the documentation strings. */
554 add_setshow_integer_cmd (char *name, enum command_class class,
556 const char *set_doc, const char *show_doc,
557 const char *help_doc,
558 cmd_sfunc_ftype *set_func,
559 show_value_ftype *show_func,
560 struct cmd_list_element **set_list,
561 struct cmd_list_element **show_list)
563 add_setshow_cmd_full (name, class, var_integer, var,
564 set_doc, show_doc, help_doc,
570 /* Add element named NAME to both the set and show command LISTs (the
571 list for set/show or some sublist thereof). CLASS is as in
572 add_cmd. VAR is address of the variable which will contain the
573 value. SET_DOC and SHOW_DOC are the documentation strings. */
575 add_setshow_uinteger_cmd (char *name, enum command_class class,
577 const char *set_doc, const char *show_doc,
578 const char *help_doc,
579 cmd_sfunc_ftype *set_func,
580 show_value_ftype *show_func,
581 struct cmd_list_element **set_list,
582 struct cmd_list_element **show_list)
584 add_setshow_cmd_full (name, class, var_uinteger, var,
585 set_doc, show_doc, help_doc,
591 /* Add element named NAME to both the set and show command LISTs (the
592 list for set/show or some sublist thereof). CLASS is as in
593 add_cmd. VAR is address of the variable which will contain the
594 value. SET_DOC and SHOW_DOC are the documentation strings. */
596 add_setshow_zinteger_cmd (char *name, enum command_class class,
598 const char *set_doc, const char *show_doc,
599 const char *help_doc,
600 cmd_sfunc_ftype *set_func,
601 show_value_ftype *show_func,
602 struct cmd_list_element **set_list,
603 struct cmd_list_element **show_list)
605 add_setshow_cmd_full (name, class, var_zinteger, var,
606 set_doc, show_doc, help_doc,
612 /* Remove the command named NAME from the command list. */
615 delete_cmd (char *name, struct cmd_list_element **list)
617 struct cmd_list_element *c;
618 struct cmd_list_element *p;
620 while (*list && strcmp ((*list)->name, name) == 0)
622 if ((*list)->hookee_pre)
623 (*list)->hookee_pre->hook_pre = 0; /* Hook slips out of its mouth */
624 if ((*list)->hookee_post)
625 (*list)->hookee_post->hook_post = 0; /* Hook slips out of its bottom */
632 for (c = *list; c->next;)
634 if (strcmp (c->next->name, name) == 0)
636 if (c->next->hookee_pre)
637 c->next->hookee_pre->hook_pre = 0; /* hooked cmd gets away. */
638 if (c->next->hookee_post)
639 c->next->hookee_post->hook_post = 0; /* remove post hook */
640 /* :( no fishing metaphore */
650 /* Shorthands to the commands above. */
652 /* Add an element to the list of info subcommands. */
654 struct cmd_list_element *
655 add_info (char *name, void (*fun) (char *, int), char *doc)
657 return add_cmd (name, no_class, fun, doc, &infolist);
660 /* Add an alias to the list of info subcommands. */
662 struct cmd_list_element *
663 add_info_alias (char *name, char *oldname, int abbrev_flag)
665 return add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
668 /* Add an element to the list of commands. */
670 struct cmd_list_element *
671 add_com (char *name, enum command_class class, void (*fun) (char *, int),
674 return add_cmd (name, class, fun, doc, &cmdlist);
677 /* Add an alias or abbreviation command to the list of commands. */
679 struct cmd_list_element *
680 add_com_alias (char *name, char *oldname, enum command_class class,
683 return add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
686 /* Recursively walk the commandlist structures, and print out the
687 documentation of commands that match our regex in either their
688 name, or their documentation.
691 apropos_cmd (struct ui_file *stream, struct cmd_list_element *commandlist,
692 struct re_pattern_buffer *regex, char *prefix)
694 struct cmd_list_element *c;
695 int returnvalue=1; /*Needed to avoid double printing*/
696 /* Walk through the commands */
697 for (c=commandlist;c;c=c->next)
701 /* Try to match against the name*/
702 returnvalue=re_search(regex,c->name,strlen(c->name),0,strlen(c->name),NULL);
703 if (returnvalue >= 0)
705 print_help_for_command (c, prefix,
706 0 /* don't recurse */, stream);
709 if (c->doc != NULL && returnvalue != 0)
711 /* Try to match against documentation */
712 if (re_search(regex,c->doc,strlen(c->doc),0,strlen(c->doc),NULL) >=0)
714 print_help_for_command (c, prefix,
715 0 /* don't recurse */, stream);
718 /* Check if this command has subcommands */
719 if (c->prefixlist != NULL)
721 /* Recursively call ourselves on the subcommand list,
722 passing the right prefix in.
724 apropos_cmd (stream,*c->prefixlist,regex,c->prefixname);
729 /* This command really has to deal with two things:
730 * 1) I want documentation on *this string* (usually called by
731 * "help commandname").
732 * 2) I want documentation on *this list* (usually called by
733 * giving a command that requires subcommands. Also called by saying
736 * I am going to split this into two seperate comamnds, help_cmd and
741 help_cmd (char *command, struct ui_file *stream)
743 struct cmd_list_element *c;
744 extern struct cmd_list_element *cmdlist;
748 help_list (cmdlist, "", all_classes, stream);
752 if (strcmp (command, "all") == 0)
758 c = lookup_cmd (&command, cmdlist, "", 0, 0);
763 /* There are three cases here.
764 If c->prefixlist is nonzero, we have a prefix command.
765 Print its documentation, then list its subcommands.
767 If c->func is non NULL, we really have a command. Print its
768 documentation and return.
770 If c->func is NULL, we have a class name. Print its
771 documentation (as if it were a command) and then set class to the
772 number of this class so that the commands in the class will be
775 fputs_filtered (c->doc, stream);
776 fputs_filtered ("\n", stream);
778 if (c->prefixlist == 0 && c->func != NULL)
780 fprintf_filtered (stream, "\n");
782 /* If this is a prefix command, print it's subcommands */
784 help_list (*c->prefixlist, c->prefixname, all_commands, stream);
786 /* If this is a class name, print all of the commands in the class */
788 help_list (cmdlist, "", c->class, stream);
790 if (c->hook_pre || c->hook_post)
791 fprintf_filtered (stream,
792 "\nThis command has a hook (or hooks) defined:\n");
795 fprintf_filtered (stream,
796 "\tThis command is run after : %s (pre hook)\n",
799 fprintf_filtered (stream,
800 "\tThis command is run before : %s (post hook)\n",
805 * Get a specific kind of help on a command list.
808 * CMDTYPE is the prefix to use in the title string.
809 * CLASS is the class with which to list the nodes of this list (see
810 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
811 * everything, ALL_CLASSES for just classes, and non-negative for only things
812 * in a specific class.
813 * and STREAM is the output stream on which to print things.
814 * If you call this routine with a class >= 0, it recurses.
817 help_list (struct cmd_list_element *list, char *cmdtype,
818 enum command_class class, struct ui_file *stream)
821 char *cmdtype1, *cmdtype2;
823 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
824 len = strlen (cmdtype);
825 cmdtype1 = (char *) alloca (len + 1);
827 cmdtype2 = (char *) alloca (len + 4);
832 strncpy (cmdtype1 + 1, cmdtype, len - 1);
834 strncpy (cmdtype2, cmdtype, len - 1);
835 strcpy (cmdtype2 + len - 1, " sub");
838 if (class == all_classes)
839 fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2);
841 fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);
843 help_cmd_list (list, class, cmdtype, (int) class >= 0, stream);
845 if (class == all_classes)
847 fprintf_filtered (stream, "\n\
848 Type \"help%s\" followed by a class name for a list of commands in ",
851 fprintf_filtered (stream, "that class.");
853 fprintf_filtered (stream, "\n\
854 Type \"help all\" for the list of all commands.");
857 fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ",
860 fputs_filtered ("for ", stream);
862 fputs_filtered ("full ", stream);
864 fputs_filtered ("documentation.\n", stream);
865 fputs_filtered ("Type \"apropos word\" to search "
866 "for commands related to \"word\".\n", stream);
867 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
872 help_all (struct ui_file *stream)
874 struct cmd_list_element *c;
875 extern struct cmd_list_element *cmdlist;
876 int seen_unclassified = 0;
878 for (c = cmdlist; c; c = c->next)
882 /* If this is a class name, print all of the commands in the class */
886 fprintf_filtered (stream, "\nCommand class: %s\n\n", c->name);
887 help_cmd_list (cmdlist, c->class, "", 1, stream);
891 /* While it's expected that all commands are in some class,
892 as a safety measure, we'll print commands outside of any
895 for (c = cmdlist; c; c = c->next)
900 if (c->class == no_class)
902 if (!seen_unclassified)
904 fprintf_filtered (stream, "\nUnclassified commands\n\n");
905 seen_unclassified = 1;
907 print_help_for_command (c, "", 1, stream);
913 /* Print only the first line of STR on STREAM. */
915 print_doc_line (struct ui_file *stream, char *str)
917 static char *line_buffer = 0;
918 static int line_size;
924 line_buffer = (char *) xmalloc (line_size);
928 while (*p && *p != '\n' && *p != '.' && *p != ',')
930 if (p - str > line_size - 1)
932 line_size = p - str + 1;
934 line_buffer = (char *) xmalloc (line_size);
936 strncpy (line_buffer, str, p - str);
937 line_buffer[p - str] = '\0';
938 if (islower (line_buffer[0]))
939 line_buffer[0] = toupper (line_buffer[0]);
940 ui_out_text (uiout, line_buffer);
943 /* Print one-line help for command C.
944 If RECURSE is non-zero, also print one-line descriptions
945 of all prefixed subcommands. */
947 print_help_for_command (struct cmd_list_element *c, char *prefix, int recurse,
948 struct ui_file *stream)
950 fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
951 print_doc_line (stream, c->doc);
952 fputs_filtered ("\n", stream);
955 && c->prefixlist != 0
956 && c->abbrev_flag == 0)
957 /* Subcommands of a prefix command typically have 'all_commands'
958 as class. If we pass CLASS to recursive invocation,
959 most often we won't see anything. */
960 help_cmd_list (*c->prefixlist, all_commands, c->prefixname, 1, stream);
964 * Implement a help command on command list LIST.
965 * RECURSE should be non-zero if this should be done recursively on
966 * all sublists of LIST.
967 * PREFIX is the prefix to print before each command name.
968 * STREAM is the stream upon which the output should be written.
970 * A non-negative class number to list only commands in that
972 * ALL_COMMANDS to list all commands in list.
973 * ALL_CLASSES to list all classes in list.
975 * Note that RECURSE will be active on *all* sublists, not just the
976 * ones selected by the criteria above (ie. the selection mechanism
977 * is at the low level, not the high-level).
980 help_cmd_list (struct cmd_list_element *list, enum command_class class,
981 char *prefix, int recurse, struct ui_file *stream)
983 struct cmd_list_element *c;
985 for (c = list; c; c = c->next)
987 if (c->abbrev_flag == 0 &&
988 (class == all_commands
989 || (class == all_classes && c->func == NULL)
990 || (class == c->class && c->func != NULL)))
992 print_help_for_command (c, prefix, recurse, stream);
998 /* Search the input clist for 'command'. Return the command if
999 found (or NULL if not), and return the number of commands
1002 static struct cmd_list_element *
1003 find_cmd (char *command, int len, struct cmd_list_element *clist,
1004 int ignore_help_classes, int *nfound)
1006 struct cmd_list_element *found, *c;
1008 found = (struct cmd_list_element *) NULL;
1010 for (c = clist; c; c = c->next)
1011 if (!strncmp (command, c->name, len)
1012 && (!ignore_help_classes || c->func))
1016 if (c->name[len] == '\0')
1026 find_command_name_length (const char *text)
1028 const char *p = text;
1030 /* Treating underscores as part of command words is important
1031 so that "set args_foo()" doesn't get interpreted as
1032 "set args _foo()". */
1033 /* Some characters are only used for TUI specific commands. However, they
1034 are always allowed for the sake of consistency.
1035 The XDB compatibility characters are only allowed when using the right
1036 mode because they clash with other GDB commands - specifically '/' is
1037 used as a suffix for print, examine and display.
1038 Note that this is larger than the character set allowed when creating
1039 user-defined commands. */
1040 while (isalnum (*p) || *p == '-' || *p == '_' ||
1041 /* Characters used by TUI specific commands. */
1042 *p == '+' || *p == '<' || *p == '>' || *p == '$' ||
1043 /* Characters used for XDB compatibility. */
1044 (xdb_commands && (*p == '!' || *p == '/' || *p == '?')))
1050 /* This routine takes a line of TEXT and a CLIST in which to start the
1051 lookup. When it returns it will have incremented the text pointer past
1052 the section of text it matched, set *RESULT_LIST to point to the list in
1053 which the last word was matched, and will return a pointer to the cmd
1054 list element which the text matches. It will return NULL if no match at
1055 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1056 matches are possible; in this case *RESULT_LIST will be set to point to
1057 the list in which there are ambiguous choices (and *TEXT will be set to
1058 the ambiguous text string).
1060 If the located command was an abbreviation, this routine returns the base
1061 command of the abbreviation.
1063 It does no error reporting whatsoever; control will always return
1064 to the superior routine.
1066 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1067 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1068 if no prefix command was ever found. For example, in the case of "info a",
1069 "info" matches without ambiguity, but "a" could be "args" or "address", so
1070 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1071 RESULT_LIST should not be interpeted as a pointer to the beginning of a
1072 list; it simply points to a specific command. In the case of an ambiguous
1073 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1074 "info t" can be "info types" or "info target"; upon return *TEXT has been
1075 advanced past "info ").
1077 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1078 affect the operation).
1080 This routine does *not* modify the text pointed to by TEXT.
1082 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1083 are actually help classes rather than commands (i.e. the function field of
1084 the struct cmd_list_element is NULL). */
1086 struct cmd_list_element *
1087 lookup_cmd_1 (char **text, struct cmd_list_element *clist,
1088 struct cmd_list_element **result_list, int ignore_help_classes)
1091 int len, tmp, nfound;
1092 struct cmd_list_element *found, *c;
1095 while (**text == ' ' || **text == '\t')
1098 /* Identify the name of the command. */
1099 len = find_command_name_length (*text);
1101 /* If nothing but whitespace, return 0. */
1105 /* *text and p now bracket the first command word to lookup (and
1106 it's length is len). We copy this into a local temporary */
1109 command = (char *) alloca (len + 1);
1110 for (tmp = 0; tmp < len; tmp++)
1112 char x = (*text)[tmp];
1115 command[len] = '\0';
1120 found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1123 ** We didn't find the command in the entered case, so lower case it
1124 ** and search again.
1126 if (!found || nfound == 0)
1128 for (tmp = 0; tmp < len; tmp++)
1130 char x = command[tmp];
1131 command[tmp] = isupper (x) ? tolower (x) : x;
1133 found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1136 /* If nothing matches, we have a simple failure. */
1142 if (result_list != NULL)
1143 /* Will be modified in calling routine
1144 if we know what the prefix command is. */
1146 return (struct cmd_list_element *) -1; /* Ambiguous. */
1149 /* We've matched something on this list. Move text pointer forward. */
1153 if (found->cmd_pointer)
1155 /* We drop the alias (abbreviation) in favor of the command it is
1156 pointing to. If the alias is deprecated, though, we need to
1157 warn the user about it before we drop it. Note that while we
1158 are warning about the alias, we may also warn about the command
1159 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1162 if (found->flags & DEPRECATED_WARN_USER)
1163 deprecated_cmd_warning (&line);
1164 found = found->cmd_pointer;
1166 /* If we found a prefix command, keep looking. */
1168 if (found->prefixlist)
1170 c = lookup_cmd_1 (text, *found->prefixlist, result_list,
1171 ignore_help_classes);
1174 /* Didn't find anything; this is as far as we got. */
1175 if (result_list != NULL)
1176 *result_list = clist;
1179 else if (c == (struct cmd_list_element *) -1)
1181 /* We've gotten this far properly, but the next step
1182 is ambiguous. We need to set the result list to the best
1183 we've found (if an inferior hasn't already set it). */
1184 if (result_list != NULL)
1186 /* This used to say *result_list = *found->prefixlist
1187 If that was correct, need to modify the documentation
1188 at the top of this function to clarify what is supposed
1190 *result_list = found;
1201 if (result_list != NULL)
1202 *result_list = clist;
1207 /* All this hair to move the space to the front of cmdtype */
1210 undef_cmd_error (char *cmdtype, char *q)
1212 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1215 *cmdtype ? " " : "",
1216 (int) strlen (cmdtype) - 1,
1220 /* Look up the contents of *LINE as a command in the command list LIST.
1221 LIST is a chain of struct cmd_list_element's.
1222 If it is found, return the struct cmd_list_element for that command
1223 and update *LINE to point after the command name, at the first argument.
1224 If not found, call error if ALLOW_UNKNOWN is zero
1225 otherwise (or if error returns) return zero.
1226 Call error if specified command is ambiguous,
1227 unless ALLOW_UNKNOWN is negative.
1228 CMDTYPE precedes the word "command" in the error message.
1230 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1231 elements which are actually help classes rather than commands (i.e.
1232 the function field of the struct cmd_list_element is 0). */
1234 struct cmd_list_element *
1235 lookup_cmd (char **line, struct cmd_list_element *list, char *cmdtype,
1236 int allow_unknown, int ignore_help_classes)
1238 struct cmd_list_element *last_list = 0;
1239 struct cmd_list_element *c;
1241 /* Note: Do not remove trailing whitespace here because this
1242 would be wrong for complete_command. Jim Kingdon */
1245 error (_("Lack of needed %scommand"), cmdtype);
1247 c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
1254 int len = find_command_name_length (*line);
1256 q = (char *) alloca (len + 1);
1257 strncpy (q, *line, len);
1259 undef_cmd_error (cmdtype, q);
1264 else if (c == (struct cmd_list_element *) -1)
1266 /* Ambigous. Local values should be off prefixlist or called
1268 int local_allow_unknown = (last_list ? last_list->allow_unknown :
1270 char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
1271 struct cmd_list_element *local_list =
1272 (last_list ? *(last_list->prefixlist) : list);
1274 if (local_allow_unknown < 0)
1277 return last_list; /* Found something. */
1279 return 0; /* Found nothing. */
1283 /* Report as error. */
1288 ((*line)[amb_len] && (*line)[amb_len] != ' '
1289 && (*line)[amb_len] != '\t');
1294 for (c = local_list; c; c = c->next)
1295 if (!strncmp (*line, c->name, amb_len))
1297 if (strlen (ambbuf) + strlen (c->name) + 6 < (int) sizeof ambbuf)
1299 if (strlen (ambbuf))
1300 strcat (ambbuf, ", ");
1301 strcat (ambbuf, c->name);
1305 strcat (ambbuf, "..");
1309 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype,
1311 return 0; /* lint */
1316 /* We've got something. It may still not be what the caller
1317 wants (if this command *needs* a subcommand). */
1318 while (**line == ' ' || **line == '\t')
1321 if (c->prefixlist && **line && !c->allow_unknown)
1322 undef_cmd_error (c->prefixname, *line);
1324 /* Seems to be what he wants. Return it. */
1330 /* We are here presumably because an alias or command in *TEXT is
1331 deprecated and a warning message should be generated. This function
1332 decodes *TEXT and potentially generates a warning message as outlined
1335 Example for 'set endian big' which has a fictitious alias 'seb'.
1337 If alias wasn't used in *TEXT, and the command is deprecated:
1338 "warning: 'set endian big' is deprecated."
1340 If alias was used, and only the alias is deprecated:
1341 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1343 If alias was used and command is deprecated (regardless of whether the
1344 alias itself is deprecated:
1346 "warning: 'set endian big' (seb) is deprecated."
1348 After the message has been sent, clear the appropriate flags in the
1349 command and/or the alias so the user is no longer bothered.
1353 deprecated_cmd_warning (char **text)
1355 struct cmd_list_element *alias = NULL;
1356 struct cmd_list_element *prefix_cmd = NULL;
1357 struct cmd_list_element *cmd = NULL;
1358 struct cmd_list_element *c;
1361 if (!lookup_cmd_composition (*text, &alias, &prefix_cmd, &cmd))
1362 /* return if text doesn't evaluate to a command */
1365 if (!((alias ? (alias->flags & DEPRECATED_WARN_USER) : 0)
1366 || (cmd->flags & DEPRECATED_WARN_USER) ) )
1367 /* return if nothing is deprecated */
1370 printf_filtered ("Warning:");
1372 if (alias && !(cmd->flags & CMD_DEPRECATED))
1373 printf_filtered (" '%s', an alias for the", alias->name);
1375 printf_filtered (" command '");
1378 printf_filtered ("%s", prefix_cmd->prefixname);
1380 printf_filtered ("%s", cmd->name);
1382 if (alias && (cmd->flags & CMD_DEPRECATED))
1383 printf_filtered ("' (%s) is deprecated.\n", alias->name);
1385 printf_filtered ("' is deprecated.\n");
1388 /* if it is only the alias that is deprecated, we want to indicate the
1389 new alias, otherwise we'll indicate the new command */
1391 if (alias && !(cmd->flags & CMD_DEPRECATED))
1393 if (alias->replacement)
1394 printf_filtered ("Use '%s'.\n\n", alias->replacement);
1396 printf_filtered ("No alternative known.\n\n");
1400 if (cmd->replacement)
1401 printf_filtered ("Use '%s'.\n\n", cmd->replacement);
1403 printf_filtered ("No alternative known.\n\n");
1406 /* We've warned you, now we'll keep quiet */
1408 alias->flags &= ~DEPRECATED_WARN_USER;
1410 cmd->flags &= ~DEPRECATED_WARN_USER;
1415 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1416 Return 1 on success, 0 on failure.
1418 If LINE refers to an alias, *alias will point to that alias.
1420 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1421 command) set *prefix_cmd.
1423 Set *cmd to point to the command LINE indicates.
1425 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1426 exist, they are NULL when we return.
1430 lookup_cmd_composition (char *text,
1431 struct cmd_list_element **alias,
1432 struct cmd_list_element **prefix_cmd,
1433 struct cmd_list_element **cmd)
1436 int len, tmp, nfound;
1437 struct cmd_list_element *cur_list;
1438 struct cmd_list_element *prev_cmd;
1447 /* Go through as many command lists as we need to
1448 to find the command TEXT refers to. */
1452 while (*text == ' ' || *text == '\t')
1455 /* Identify the name of the command. */
1456 len = find_command_name_length (text);
1458 /* If nothing but whitespace, return. */
1462 /* text is the start of the first command word to lookup (and
1463 it's length is len). We copy this into a local temporary */
1465 command = (char *) alloca (len + 1);
1466 for (tmp = 0; tmp < len; tmp++)
1471 command[len] = '\0';
1476 *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1478 /* We didn't find the command in the entered case, so lower case it
1481 if (!*cmd || nfound == 0)
1483 for (tmp = 0; tmp < len; tmp++)
1485 char x = command[tmp];
1486 command[tmp] = isupper (x) ? tolower (x) : x;
1488 *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1491 if (*cmd == (struct cmd_list_element *) -1)
1493 return 0; /* ambiguous */
1497 return 0; /* nothing found */
1500 if ((*cmd)->cmd_pointer)
1502 /* cmd was actually an alias, we note that an alias was used
1503 (by assigning *alais) and we set *cmd.
1506 *cmd = (*cmd)->cmd_pointer;
1508 *prefix_cmd = prev_cmd;
1510 if ((*cmd)->prefixlist)
1511 cur_list = *(*cmd)->prefixlist;
1519 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1521 /* Return a vector of char pointers which point to the different
1522 possible completions in LIST of TEXT.
1524 WORD points in the same buffer as TEXT, and completions should be
1525 returned relative to this position. For example, suppose TEXT is "foo"
1526 and we want to complete to "foobar". If WORD is "oo", return
1527 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1530 complete_on_cmdlist (struct cmd_list_element *list, char *text, char *word)
1532 struct cmd_list_element *ptr;
1534 int sizeof_matchlist;
1536 int textlen = strlen (text);
1538 sizeof_matchlist = 10;
1539 matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *));
1542 for (ptr = list; ptr; ptr = ptr->next)
1543 if (!strncmp (ptr->name, text, textlen)
1544 && !ptr->abbrev_flag
1546 || ptr->prefixlist))
1548 if (matches == sizeof_matchlist)
1550 sizeof_matchlist *= 2;
1551 matchlist = (char **) xrealloc ((char *) matchlist,
1553 * sizeof (char *)));
1556 matchlist[matches] = (char *)
1557 xmalloc (strlen (word) + strlen (ptr->name) + 1);
1559 strcpy (matchlist[matches], ptr->name);
1560 else if (word > text)
1562 /* Return some portion of ptr->name. */
1563 strcpy (matchlist[matches], ptr->name + (word - text));
1567 /* Return some of text plus ptr->name. */
1568 strncpy (matchlist[matches], word, text - word);
1569 matchlist[matches][text - word] = '\0';
1570 strcat (matchlist[matches], ptr->name);
1582 matchlist = (char **) xrealloc ((char *) matchlist, ((matches + 1)
1583 * sizeof (char *)));
1584 matchlist[matches] = (char *) 0;
1590 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1592 /* Return a vector of char pointers which point to the different
1593 possible completions in CMD of TEXT.
1595 WORD points in the same buffer as TEXT, and completions should be
1596 returned relative to this position. For example, suppose TEXT is "foo"
1597 and we want to complete to "foobar". If WORD is "oo", return
1598 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1601 complete_on_enum (const char *enumlist[],
1606 int sizeof_matchlist;
1608 int textlen = strlen (text);
1612 sizeof_matchlist = 10;
1613 matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *));
1616 for (i = 0; (name = enumlist[i]) != NULL; i++)
1617 if (strncmp (name, text, textlen) == 0)
1619 if (matches == sizeof_matchlist)
1621 sizeof_matchlist *= 2;
1622 matchlist = (char **) xrealloc ((char *) matchlist,
1624 * sizeof (char *)));
1627 matchlist[matches] = (char *)
1628 xmalloc (strlen (word) + strlen (name) + 1);
1630 strcpy (matchlist[matches], name);
1631 else if (word > text)
1633 /* Return some portion of name. */
1634 strcpy (matchlist[matches], name + (word - text));
1638 /* Return some of text plus name. */
1639 strncpy (matchlist[matches], word, text - word);
1640 matchlist[matches][text - word] = '\0';
1641 strcat (matchlist[matches], name);
1653 matchlist = (char **) xrealloc ((char *) matchlist, ((matches + 1)
1654 * sizeof (char *)));
1655 matchlist[matches] = (char *) 0;
1662 /* check function pointer */
1664 cmd_func_p (struct cmd_list_element *cmd)
1666 return (cmd->func != NULL);
1670 /* call the command function */
1672 cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
1674 if (cmd_func_p (cmd))
1675 (*cmd->func) (cmd, args, from_tty);
1677 error (_("Invalid command"));