1 /* Handle lists of commands, their decoding and documentation, for GDB.
3 Copyright 1986, 1989, 1990, 1991, 1998, 2000, 2001, 2002, 2004 Free
4 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 2 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, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 #include "gdb_regex.h"
25 #include "gdb_string.h"
29 #include "cli/cli-cmds.h"
30 #include "cli/cli-decode.h"
33 #include "tui/tui.h" /* For tui_active et.al. */
36 #include "gdb_assert.h"
38 /* Prototypes for local functions */
40 static void undef_cmd_error (char *, char *);
42 static struct cmd_list_element
*find_cmd (char *command
,
44 struct cmd_list_element
*clist
,
45 int ignore_help_classes
,
48 static void help_all (struct ui_file
*stream
);
50 /* Set the callback function for the specified command. For each both
51 the commands callback and func() are set. The latter set to a
52 bounce function (unless cfunc / sfunc is NULL that is). */
55 do_cfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
57 c
->function
.cfunc (args
, from_tty
); /* Ok. */
61 set_cmd_cfunc (struct cmd_list_element
*cmd
, cmd_cfunc_ftype
*cfunc
)
67 cmd
->function
.cfunc
= cfunc
; /* Ok. */
71 do_sfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
73 c
->function
.sfunc (args
, from_tty
, c
); /* Ok. */
77 set_cmd_sfunc (struct cmd_list_element
*cmd
, cmd_sfunc_ftype
*sfunc
)
83 cmd
->function
.sfunc
= sfunc
; /* Ok. */
87 cmd_cfunc_eq (struct cmd_list_element
*cmd
,
88 void (*cfunc
) (char *args
, int from_tty
))
90 return cmd
->func
== do_cfunc
&& cmd
->function
.cfunc
== cfunc
;
94 set_cmd_context (struct cmd_list_element
*cmd
, void *context
)
96 cmd
->context
= context
;
100 get_cmd_context (struct cmd_list_element
*cmd
)
106 cmd_type (struct cmd_list_element
*cmd
)
112 set_cmd_completer (struct cmd_list_element
*cmd
,
113 char **(*completer
) (char *text
, char *word
))
115 cmd
->completer
= completer
; /* Ok. */
119 /* Add element named NAME.
120 CLASS is the top level category into which commands are broken down
122 FUN should be the function to execute the command;
123 it will get a character string as argument, with leading
124 and trailing blanks already eliminated.
126 DOC is a documentation string for the command.
127 Its first line should be a complete sentence.
128 It should start with ? for a command that is an abbreviation
129 or with * for a command that most users don't need to know about.
131 Add this command to command list *LIST.
133 Returns a pointer to the added command (not necessarily the head
136 struct cmd_list_element
*
137 add_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
138 char *doc
, struct cmd_list_element
**list
)
140 struct cmd_list_element
*c
141 = (struct cmd_list_element
*) xmalloc (sizeof (struct cmd_list_element
));
142 struct cmd_list_element
*p
;
144 delete_cmd (name
, list
);
146 if (*list
== NULL
|| strcmp ((*list
)->name
, name
) >= 0)
154 while (p
->next
&& strcmp (p
->next
->name
, name
) <= 0)
164 set_cmd_cfunc (c
, fun
);
165 set_cmd_context (c
, NULL
);
168 c
->replacement
= NULL
;
169 c
->pre_show_hook
= NULL
;
173 c
->prefixlist
= NULL
;
174 c
->prefixname
= NULL
;
175 c
->allow_unknown
= 0;
177 set_cmd_completer (c
, make_symbol_completion_list
);
178 c
->type
= not_set_cmd
;
180 c
->var_type
= var_boolean
;
182 c
->user_commands
= NULL
;
183 c
->hookee_pre
= NULL
;
184 c
->hookee_post
= NULL
;
185 c
->cmd_pointer
= NULL
;
190 /* Deprecates a command CMD.
191 REPLACEMENT is the name of the command which should be used in place
192 of this command, or NULL if no such command exists.
194 This function does not check to see if command REPLACEMENT exists
195 since gdb may not have gotten around to adding REPLACEMENT when this
198 Returns a pointer to the deprecated command. */
200 struct cmd_list_element
*
201 deprecate_cmd (struct cmd_list_element
*cmd
, char *replacement
)
203 cmd
->flags
|= (CMD_DEPRECATED
| DEPRECATED_WARN_USER
);
205 if (replacement
!= NULL
)
206 cmd
->replacement
= replacement
;
208 cmd
->replacement
= NULL
;
213 struct cmd_list_element
*
214 add_alias_cmd (char *name
, char *oldname
, enum command_class
class,
215 int abbrev_flag
, struct cmd_list_element
**list
)
217 /* Must do this since lookup_cmd tries to side-effect its first arg */
219 struct cmd_list_element
*old
;
220 struct cmd_list_element
*c
;
221 copied_name
= (char *) alloca (strlen (oldname
) + 1);
222 strcpy (copied_name
, oldname
);
223 old
= lookup_cmd (&copied_name
, *list
, "", 1, 1);
227 delete_cmd (name
, list
);
231 c
= add_cmd (name
, class, NULL
, old
->doc
, list
);
232 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
234 c
->function
= old
->function
;
235 c
->prefixlist
= old
->prefixlist
;
236 c
->prefixname
= old
->prefixname
;
237 c
->allow_unknown
= old
->allow_unknown
;
238 c
->abbrev_flag
= abbrev_flag
;
239 c
->cmd_pointer
= old
;
243 /* Like add_cmd but adds an element for a command prefix:
244 a name that should be followed by a subcommand to be looked up
245 in another command list. PREFIXLIST should be the address
246 of the variable containing that list. */
248 struct cmd_list_element
*
249 add_prefix_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
250 char *doc
, struct cmd_list_element
**prefixlist
,
251 char *prefixname
, int allow_unknown
,
252 struct cmd_list_element
**list
)
254 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
255 c
->prefixlist
= prefixlist
;
256 c
->prefixname
= prefixname
;
257 c
->allow_unknown
= allow_unknown
;
261 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
263 struct cmd_list_element
*
264 add_abbrev_prefix_cmd (char *name
, enum command_class
class,
265 void (*fun
) (char *, int), char *doc
,
266 struct cmd_list_element
**prefixlist
, char *prefixname
,
267 int allow_unknown
, 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
;
277 /* This is an empty "cfunc". */
279 not_just_help_class_command (char *args
, int from_tty
)
283 /* This is an empty "sfunc". */
284 static void empty_sfunc (char *, int, struct cmd_list_element
*);
287 empty_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
291 /* Add element named NAME to command list LIST (the list for set/show
292 or some sublist thereof).
293 TYPE is set_cmd or show_cmd.
294 CLASS is as in add_cmd.
295 VAR_TYPE is the kind of thing we are setting.
296 VAR is address of the variable being controlled by this command.
297 DOC is the documentation string. */
299 static struct cmd_list_element
*
300 add_set_or_show_cmd (char *name
,
302 enum command_class
class,
306 struct cmd_list_element
**list
)
308 struct cmd_list_element
*c
= add_cmd (name
, class, NULL
, doc
, list
);
309 gdb_assert (type
== set_cmd
|| type
== show_cmd
);
311 c
->var_type
= var_type
;
313 /* This needs to be something besides NULL so that this isn't
314 treated as a help class. */
315 set_cmd_sfunc (c
, empty_sfunc
);
319 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
320 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
321 setting. VAR is address of the variable being controlled by this
322 command. SET_FUNC and SHOW_FUNC are the callback functions (if
323 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
324 strings. PRINT the format string to print the value. SET_RESULT
325 and SHOW_RESULT, if not NULL, are set to the resulting command
329 add_setshow_cmd_full (char *name
,
330 enum command_class
class,
331 var_types var_type
, void *var
,
332 const char *set_doc
, const char *show_doc
,
333 const char *help_doc
, const char *print
,
334 cmd_sfunc_ftype
*set_func
,
335 cmd_sfunc_ftype
*show_func
,
336 struct cmd_list_element
**set_list
,
337 struct cmd_list_element
**show_list
,
338 struct cmd_list_element
**set_result
,
339 struct cmd_list_element
**show_result
)
341 struct cmd_list_element
*set
;
342 struct cmd_list_element
*show
;
343 char *full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
344 char *full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
345 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
346 full_set_doc
, set_list
);
347 if (set_func
!= NULL
)
348 set_cmd_sfunc (set
, set_func
);
349 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
350 full_show_doc
, show_list
);
351 if (show_func
!= NULL
)
352 set_cmd_sfunc (show
, show_func
);
354 if (set_result
!= NULL
)
356 if (show_result
!= NULL
)
360 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
361 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
362 setting. VAR is address of the variable being controlled by this
363 command. SET_FUNC and SHOW_FUNC are the callback functions (if
364 non-NULL). SET_DOC and SHOW_DOC are the documentation strings. */
367 add_setshow_cmd (char *name
,
368 enum command_class
class,
369 var_types var_type
, void *var
,
370 const char *set_doc
, const char *show_doc
,
371 const char *help_doc
, const char *print
,
372 cmd_sfunc_ftype
*set_func
, cmd_sfunc_ftype
*show_func
,
373 struct cmd_list_element
**set_list
,
374 struct cmd_list_element
**show_list
)
376 add_setshow_cmd_full (name
, class, var_type
, var
,
377 set_doc
, show_doc
, help_doc
, print
,
378 set_func
, show_func
, set_list
, show_list
,
382 struct cmd_list_element
*
383 add_set_cmd (char *name
,
384 enum command_class
class,
388 struct cmd_list_element
**list
)
390 return add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
, doc
, list
);
393 /* Add element named NAME to command list LIST (the list for set
394 or some sublist thereof).
395 CLASS is as in add_cmd.
396 ENUMLIST is a list of strings which may follow NAME.
397 VAR is address of the variable which will contain the matching string
399 DOC is the documentation string. */
401 struct cmd_list_element
*
402 add_set_enum_cmd (char *name
,
403 enum command_class
class,
404 const char *enumlist
[],
407 struct cmd_list_element
**list
)
409 struct cmd_list_element
*c
410 = add_set_cmd (name
, class, var_enum
, var
, doc
, list
);
416 /* Add an auto-boolean command named NAME to both the set and show
417 command list lists. CLASS is as in add_cmd. VAR is address of the
418 variable which will contain the value. DOC is the documentation
419 string. FUNC is the corresponding callback. */
421 add_setshow_auto_boolean_cmd (char *name
,
422 enum command_class
class,
423 enum auto_boolean
*var
,
424 const char *set_doc
, const char *show_doc
,
425 const char *help_doc
, const char *print
,
426 cmd_sfunc_ftype
*set_func
,
427 cmd_sfunc_ftype
*show_func
,
428 struct cmd_list_element
**set_list
,
429 struct cmd_list_element
**show_list
)
431 static const char *auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
432 struct cmd_list_element
*c
;
433 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
434 set_doc
, show_doc
, help_doc
, print
,
438 c
->enums
= auto_boolean_enums
;
441 /* Add element named NAME to both the set and show command LISTs (the
442 list for set/show or some sublist thereof). CLASS is as in
443 add_cmd. VAR is address of the variable which will contain the
444 value. SET_DOC and SHOW_DOC are the documentation strings. */
446 add_setshow_boolean_cmd (char *name
, enum command_class
class, int *var
,
447 const char *set_doc
, const char *show_doc
,
448 const char *help_doc
, const char *print
,
449 cmd_sfunc_ftype
*set_func
,
450 cmd_sfunc_ftype
*show_func
,
451 struct cmd_list_element
**set_list
,
452 struct cmd_list_element
**show_list
)
454 static const char *boolean_enums
[] = { "on", "off", NULL
};
455 struct cmd_list_element
*c
;
456 add_setshow_cmd_full (name
, class, var_boolean
, var
,
457 set_doc
, show_doc
, help_doc
, print
,
461 c
->enums
= boolean_enums
;
464 /* Add element named NAME to both the set and show command LISTs (the
465 list for set/show or some sublist thereof). CLASS is as in
466 add_cmd. VAR is address of the variable which will contain the
467 value. SET_DOC and SHOW_DOC are the documentation strings. */
469 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
471 const char *set_doc
, const char *show_doc
,
472 const char *help_doc
, const char *print
,
473 cmd_sfunc_ftype
*set_func
,
474 cmd_sfunc_ftype
*show_func
,
475 struct cmd_list_element
**set_list
,
476 struct cmd_list_element
**show_list
)
478 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
479 set_doc
, show_doc
, help_doc
, print
,
485 /* Add element named NAME to both the set and show command LISTs (the
486 list for set/show or some sublist thereof). CLASS is as in
487 add_cmd. VAR is address of the variable which will contain the
488 value. SET_DOC and SHOW_DOC are the documentation strings. */
490 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
492 const char *set_doc
, const char *show_doc
,
493 const char *help_doc
, const char *print
,
494 cmd_sfunc_ftype
*set_func
,
495 cmd_sfunc_ftype
*show_func
,
496 struct cmd_list_element
**set_list
,
497 struct cmd_list_element
**show_list
)
499 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
500 set_doc
, show_doc
, help_doc
, print
,
506 /* Where SETCMD has already been added, add the corresponding show
507 command to LIST and return a pointer to the added command (not
508 necessarily the head of LIST). */
509 /* NOTE: cagney/2002-03-17: The original version of
510 deprecated_add_show_from_set used memcpy() to clone `set' into
511 `show'. This meant that in addition to all the needed fields (var,
512 name, et.al.) some unnecessary fields were copied (namely the
513 callback function). The function explictly copies relevant fields.
514 For a `set' and `show' command to share the same callback, the
515 caller must set both explicitly. */
516 struct cmd_list_element
*
517 deprecated_add_show_from_set (struct cmd_list_element
*setcmd
,
518 struct cmd_list_element
**list
)
521 const static char setstring
[] = "Set ";
523 /* Create a doc string by replacing "Set " at the start of the
524 `set'' command's doco with "Show ". */
525 gdb_assert (strncmp (setcmd
->doc
, setstring
, sizeof (setstring
) - 1) == 0);
526 doc
= concat ("Show ", setcmd
->doc
+ sizeof (setstring
) - 1, NULL
);
528 /* Insert the basic command. */
529 return add_set_or_show_cmd (setcmd
->name
, show_cmd
, setcmd
->class,
530 setcmd
->var_type
, setcmd
->var
, doc
, list
);
533 /* Remove the command named NAME from the command list. */
536 delete_cmd (char *name
, struct cmd_list_element
**list
)
538 struct cmd_list_element
*c
;
539 struct cmd_list_element
*p
;
541 while (*list
&& strcmp ((*list
)->name
, name
) == 0)
543 if ((*list
)->hookee_pre
)
544 (*list
)->hookee_pre
->hook_pre
= 0; /* Hook slips out of its mouth */
545 if ((*list
)->hookee_post
)
546 (*list
)->hookee_post
->hook_post
= 0; /* Hook slips out of its bottom */
553 for (c
= *list
; c
->next
;)
555 if (strcmp (c
->next
->name
, name
) == 0)
557 if (c
->next
->hookee_pre
)
558 c
->next
->hookee_pre
->hook_pre
= 0; /* hooked cmd gets away. */
559 if (c
->next
->hookee_post
)
560 c
->next
->hookee_post
->hook_post
= 0; /* remove post hook */
561 /* :( no fishing metaphore */
571 /* Shorthands to the commands above. */
573 /* Add an element to the list of info subcommands. */
575 struct cmd_list_element
*
576 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
578 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
581 /* Add an alias to the list of info subcommands. */
583 struct cmd_list_element
*
584 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
586 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
589 /* Add an element to the list of commands. */
591 struct cmd_list_element
*
592 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
595 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
598 /* Add an alias or abbreviation command to the list of commands. */
600 struct cmd_list_element
*
601 add_com_alias (char *name
, char *oldname
, enum command_class
class,
604 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
607 /* Recursively walk the commandlist structures, and print out the
608 documentation of commands that match our regex in either their
609 name, or their documentation.
612 apropos_cmd (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
613 struct re_pattern_buffer
*regex
, char *prefix
)
615 struct cmd_list_element
*c
;
616 int returnvalue
=1; /*Needed to avoid double printing*/
617 /* Walk through the commands */
618 for (c
=commandlist
;c
;c
=c
->next
)
622 /* Try to match against the name*/
623 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
624 if (returnvalue
>= 0)
626 /* Stolen from help_cmd_list. We don't directly use
627 * help_cmd_list because it doesn't let us print out
630 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
631 print_doc_line (stream
, c
->doc
);
632 fputs_filtered ("\n", stream
);
633 returnvalue
=0; /*Set this so we don't print it again.*/
636 if (c
->doc
!= NULL
&& returnvalue
!= 0)
638 /* Try to match against documentation */
639 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
641 /* Stolen from help_cmd_list. We don't directly use
642 * help_cmd_list because it doesn't let us print out
645 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
646 print_doc_line (stream
, c
->doc
);
647 fputs_filtered ("\n", stream
);
650 /* Check if this command has subcommands */
651 if (c
->prefixlist
!= NULL
)
653 /* Recursively call ourselves on the subcommand list,
654 passing the right prefix in.
656 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
661 /* This command really has to deal with two things:
662 * 1) I want documentation on *this string* (usually called by
663 * "help commandname").
664 * 2) I want documentation on *this list* (usually called by
665 * giving a command that requires subcommands. Also called by saying
668 * I am going to split this into two seperate comamnds, help_cmd and
673 help_cmd (char *command
, struct ui_file
*stream
)
675 struct cmd_list_element
*c
;
676 extern struct cmd_list_element
*cmdlist
;
680 help_list (cmdlist
, "", all_classes
, stream
);
684 if (strcmp (command
, "all") == 0)
690 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
695 /* There are three cases here.
696 If c->prefixlist is nonzero, we have a prefix command.
697 Print its documentation, then list its subcommands.
699 If c->func is non NULL, we really have a command. Print its
700 documentation and return.
702 If c->func is NULL, we have a class name. Print its
703 documentation (as if it were a command) and then set class to the
704 number of this class so that the commands in the class will be
707 fputs_filtered (c
->doc
, stream
);
708 fputs_filtered ("\n", stream
);
710 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
712 fprintf_filtered (stream
, "\n");
714 /* If this is a prefix command, print it's subcommands */
716 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
718 /* If this is a class name, print all of the commands in the class */
720 help_list (cmdlist
, "", c
->class, stream
);
722 if (c
->hook_pre
|| c
->hook_post
)
723 fprintf_filtered (stream
,
724 "\nThis command has a hook (or hooks) defined:\n");
727 fprintf_filtered (stream
,
728 "\tThis command is run after : %s (pre hook)\n",
731 fprintf_filtered (stream
,
732 "\tThis command is run before : %s (post hook)\n",
737 * Get a specific kind of help on a command list.
740 * CMDTYPE is the prefix to use in the title string.
741 * CLASS is the class with which to list the nodes of this list (see
742 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
743 * everything, ALL_CLASSES for just classes, and non-negative for only things
744 * in a specific class.
745 * and STREAM is the output stream on which to print things.
746 * If you call this routine with a class >= 0, it recurses.
749 help_list (struct cmd_list_element
*list
, char *cmdtype
,
750 enum command_class
class, struct ui_file
*stream
)
753 char *cmdtype1
, *cmdtype2
;
755 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
756 len
= strlen (cmdtype
);
757 cmdtype1
= (char *) alloca (len
+ 1);
759 cmdtype2
= (char *) alloca (len
+ 4);
764 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
766 strncpy (cmdtype2
, cmdtype
, len
- 1);
767 strcpy (cmdtype2
+ len
- 1, " sub");
770 if (class == all_classes
)
771 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
773 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
775 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
777 if (class == all_classes
)
779 fprintf_filtered (stream
, "\n\
780 Type \"help%s\" followed by a class name for a list of commands in ",
783 fprintf_filtered (stream
, "that class.");
786 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
789 fputs_filtered ("for ", stream
);
791 fputs_filtered ("full ", stream
);
793 fputs_filtered ("documentation.\n", stream
);
794 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
799 help_all (struct ui_file
*stream
)
801 struct cmd_list_element
*c
;
802 extern struct cmd_list_element
*cmdlist
;
804 for (c
= cmdlist
; c
; c
= c
->next
)
808 /* If this is a prefix command, print it's subcommands */
810 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 0, stream
);
812 /* If this is a class name, print all of the commands in the class */
813 else if (c
->func
== NULL
)
814 help_cmd_list (cmdlist
, c
->class, "", 0, stream
);
818 /* Print only the first line of STR on STREAM. */
820 print_doc_line (struct ui_file
*stream
, char *str
)
822 static char *line_buffer
= 0;
823 static int line_size
;
829 line_buffer
= (char *) xmalloc (line_size
);
833 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
835 if (p
- str
> line_size
- 1)
837 line_size
= p
- str
+ 1;
839 line_buffer
= (char *) xmalloc (line_size
);
841 strncpy (line_buffer
, str
, p
- str
);
842 line_buffer
[p
- str
] = '\0';
843 if (islower (line_buffer
[0]))
844 line_buffer
[0] = toupper (line_buffer
[0]);
845 ui_out_text (uiout
, line_buffer
);
849 * Implement a help command on command list LIST.
850 * RECURSE should be non-zero if this should be done recursively on
851 * all sublists of LIST.
852 * PREFIX is the prefix to print before each command name.
853 * STREAM is the stream upon which the output should be written.
855 * A non-negative class number to list only commands in that
857 * ALL_COMMANDS to list all commands in list.
858 * ALL_CLASSES to list all classes in list.
860 * Note that RECURSE will be active on *all* sublists, not just the
861 * ones selected by the criteria above (ie. the selection mechanism
862 * is at the low level, not the high-level).
865 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
866 char *prefix
, int recurse
, struct ui_file
*stream
)
868 struct cmd_list_element
*c
;
870 for (c
= list
; c
; c
= c
->next
)
872 if (c
->abbrev_flag
== 0 &&
873 (class == all_commands
874 || (class == all_classes
&& c
->func
== NULL
)
875 || (class == c
->class && c
->func
!= NULL
)))
877 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
878 print_doc_line (stream
, c
->doc
);
879 fputs_filtered ("\n", stream
);
882 && c
->prefixlist
!= 0
883 && c
->abbrev_flag
== 0)
884 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
, 1, stream
);
889 /* Search the input clist for 'command'. Return the command if
890 found (or NULL if not), and return the number of commands
893 static struct cmd_list_element
*
894 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
895 int ignore_help_classes
, int *nfound
)
897 struct cmd_list_element
*found
, *c
;
899 found
= (struct cmd_list_element
*) NULL
;
901 for (c
= clist
; c
; c
= c
->next
)
902 if (!strncmp (command
, c
->name
, len
)
903 && (!ignore_help_classes
|| c
->func
))
907 if (c
->name
[len
] == '\0')
916 /* This routine takes a line of TEXT and a CLIST in which to start the
917 lookup. When it returns it will have incremented the text pointer past
918 the section of text it matched, set *RESULT_LIST to point to the list in
919 which the last word was matched, and will return a pointer to the cmd
920 list element which the text matches. It will return NULL if no match at
921 all was possible. It will return -1 (cast appropriately, ick) if ambigous
922 matches are possible; in this case *RESULT_LIST will be set to point to
923 the list in which there are ambiguous choices (and *TEXT will be set to
924 the ambiguous text string).
926 If the located command was an abbreviation, this routine returns the base
927 command of the abbreviation.
929 It does no error reporting whatsoever; control will always return
930 to the superior routine.
932 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
933 at the prefix_command (ie. the best match) *or* (special case) will be NULL
934 if no prefix command was ever found. For example, in the case of "info a",
935 "info" matches without ambiguity, but "a" could be "args" or "address", so
936 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
937 RESULT_LIST should not be interpeted as a pointer to the beginning of a
938 list; it simply points to a specific command. In the case of an ambiguous
939 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
940 "info t" can be "info types" or "info target"; upon return *TEXT has been
941 advanced past "info ").
943 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
944 affect the operation).
946 This routine does *not* modify the text pointed to by TEXT.
948 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
949 are actually help classes rather than commands (i.e. the function field of
950 the struct cmd_list_element is NULL). */
952 struct cmd_list_element
*
953 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
954 struct cmd_list_element
**result_list
, int ignore_help_classes
)
957 int len
, tmp
, nfound
;
958 struct cmd_list_element
*found
, *c
;
961 while (**text
== ' ' || **text
== '\t')
964 /* Treating underscores as part of command words is important
965 so that "set args_foo()" doesn't get interpreted as
966 "set args _foo()". */
967 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
970 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
973 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
975 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
979 /* If nothing but whitespace, return 0. */
985 /* *text and p now bracket the first command word to lookup (and
986 it's length is len). We copy this into a local temporary */
989 command
= (char *) alloca (len
+ 1);
990 for (tmp
= 0; tmp
< len
; tmp
++)
992 char x
= (*text
)[tmp
];
1000 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1003 ** We didn't find the command in the entered case, so lower case it
1004 ** and search again.
1006 if (!found
|| nfound
== 0)
1008 for (tmp
= 0; tmp
< len
; tmp
++)
1010 char x
= command
[tmp
];
1011 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1013 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1016 /* If nothing matches, we have a simple failure. */
1022 if (result_list
!= NULL
)
1023 /* Will be modified in calling routine
1024 if we know what the prefix command is. */
1026 return (struct cmd_list_element
*) -1; /* Ambiguous. */
1029 /* We've matched something on this list. Move text pointer forward. */
1033 if (found
->cmd_pointer
)
1035 /* We drop the alias (abbreviation) in favor of the command it is
1036 pointing to. If the alias is deprecated, though, we need to
1037 warn the user about it before we drop it. Note that while we
1038 are warning about the alias, we may also warn about the command
1039 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1042 if (found
->flags
& DEPRECATED_WARN_USER
)
1043 deprecated_cmd_warning (&line
);
1044 found
= found
->cmd_pointer
;
1046 /* If we found a prefix command, keep looking. */
1048 if (found
->prefixlist
)
1050 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1051 ignore_help_classes
);
1054 /* Didn't find anything; this is as far as we got. */
1055 if (result_list
!= NULL
)
1056 *result_list
= clist
;
1059 else if (c
== (struct cmd_list_element
*) -1)
1061 /* We've gotten this far properly, but the next step
1062 is ambiguous. We need to set the result list to the best
1063 we've found (if an inferior hasn't already set it). */
1064 if (result_list
!= NULL
)
1066 /* This used to say *result_list = *found->prefixlist
1067 If that was correct, need to modify the documentation
1068 at the top of this function to clarify what is supposed
1070 *result_list
= found
;
1081 if (result_list
!= NULL
)
1082 *result_list
= clist
;
1087 /* All this hair to move the space to the front of cmdtype */
1090 undef_cmd_error (char *cmdtype
, char *q
)
1092 error ("Undefined %scommand: \"%s\". Try \"help%s%.*s\".",
1095 *cmdtype
? " " : "",
1096 (int) strlen (cmdtype
) - 1,
1100 /* Look up the contents of *LINE as a command in the command list LIST.
1101 LIST is a chain of struct cmd_list_element's.
1102 If it is found, return the struct cmd_list_element for that command
1103 and update *LINE to point after the command name, at the first argument.
1104 If not found, call error if ALLOW_UNKNOWN is zero
1105 otherwise (or if error returns) return zero.
1106 Call error if specified command is ambiguous,
1107 unless ALLOW_UNKNOWN is negative.
1108 CMDTYPE precedes the word "command" in the error message.
1110 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1111 elements which are actually help classes rather than commands (i.e.
1112 the function field of the struct cmd_list_element is 0). */
1114 struct cmd_list_element
*
1115 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1116 int allow_unknown
, int ignore_help_classes
)
1118 struct cmd_list_element
*last_list
= 0;
1119 struct cmd_list_element
*c
=
1120 lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1122 /* Note: Do not remove trailing whitespace here because this
1123 would be wrong for complete_command. Jim Kingdon */
1130 error ("Lack of needed %scommand", cmdtype
);
1133 char *p
= *line
, *q
;
1135 while (isalnum (*p
) || *p
== '-')
1138 q
= (char *) alloca (p
- *line
+ 1);
1139 strncpy (q
, *line
, p
- *line
);
1140 q
[p
- *line
] = '\0';
1141 undef_cmd_error (cmdtype
, q
);
1147 else if (c
== (struct cmd_list_element
*) -1)
1149 /* Ambigous. Local values should be off prefixlist or called
1151 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1153 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1154 struct cmd_list_element
*local_list
=
1155 (last_list
? *(last_list
->prefixlist
) : list
);
1157 if (local_allow_unknown
< 0)
1160 return last_list
; /* Found something. */
1162 return 0; /* Found nothing. */
1166 /* Report as error. */
1171 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1172 && (*line
)[amb_len
] != '\t');
1177 for (c
= local_list
; c
; c
= c
->next
)
1178 if (!strncmp (*line
, c
->name
, amb_len
))
1180 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1182 if (strlen (ambbuf
))
1183 strcat (ambbuf
, ", ");
1184 strcat (ambbuf
, c
->name
);
1188 strcat (ambbuf
, "..");
1192 error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype
,
1194 return 0; /* lint */
1199 /* We've got something. It may still not be what the caller
1200 wants (if this command *needs* a subcommand). */
1201 while (**line
== ' ' || **line
== '\t')
1204 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1205 undef_cmd_error (c
->prefixname
, *line
);
1207 /* Seems to be what he wants. Return it. */
1213 /* We are here presumably because an alias or command in *TEXT is
1214 deprecated and a warning message should be generated. This function
1215 decodes *TEXT and potentially generates a warning message as outlined
1218 Example for 'set endian big' which has a fictitious alias 'seb'.
1220 If alias wasn't used in *TEXT, and the command is deprecated:
1221 "warning: 'set endian big' is deprecated."
1223 If alias was used, and only the alias is deprecated:
1224 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1226 If alias was used and command is deprecated (regardless of whether the
1227 alias itself is deprecated:
1229 "warning: 'set endian big' (seb) is deprecated."
1231 After the message has been sent, clear the appropriate flags in the
1232 command and/or the alias so the user is no longer bothered.
1236 deprecated_cmd_warning (char **text
)
1238 struct cmd_list_element
*alias
= NULL
;
1239 struct cmd_list_element
*prefix_cmd
= NULL
;
1240 struct cmd_list_element
*cmd
= NULL
;
1241 struct cmd_list_element
*c
;
1244 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1245 /* return if text doesn't evaluate to a command */
1248 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1249 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1250 /* return if nothing is deprecated */
1253 printf_filtered ("Warning:");
1255 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1256 printf_filtered (" '%s', an alias for the", alias
->name
);
1258 printf_filtered (" command '");
1261 printf_filtered ("%s", prefix_cmd
->prefixname
);
1263 printf_filtered ("%s", cmd
->name
);
1265 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1266 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1268 printf_filtered ("' is deprecated.\n");
1271 /* if it is only the alias that is deprecated, we want to indicate the
1272 new alias, otherwise we'll indicate the new command */
1274 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1276 if (alias
->replacement
)
1277 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1279 printf_filtered ("No alternative known.\n\n");
1283 if (cmd
->replacement
)
1284 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1286 printf_filtered ("No alternative known.\n\n");
1289 /* We've warned you, now we'll keep quiet */
1291 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1293 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1298 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1299 Return 1 on success, 0 on failure.
1301 If LINE refers to an alias, *alias will point to that alias.
1303 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1304 command) set *prefix_cmd.
1306 Set *cmd to point to the command LINE indicates.
1308 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1309 exist, they are NULL when we return.
1313 lookup_cmd_composition (char *text
,
1314 struct cmd_list_element
**alias
,
1315 struct cmd_list_element
**prefix_cmd
,
1316 struct cmd_list_element
**cmd
)
1319 int len
, tmp
, nfound
;
1320 struct cmd_list_element
*cur_list
;
1321 struct cmd_list_element
*prev_cmd
;
1330 /* Go through as many command lists as we need to
1331 to find the command TEXT refers to. */
1335 while (*text
== ' ' || *text
== '\t')
1338 /* Treating underscores as part of command words is important
1339 so that "set args_foo()" doesn't get interpreted as
1340 "set args _foo()". */
1341 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1344 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1347 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1349 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1353 /* If nothing but whitespace, return. */
1359 /* text and p now bracket the first command word to lookup (and
1360 it's length is len). We copy this into a local temporary */
1362 command
= (char *) alloca (len
+ 1);
1363 for (tmp
= 0; tmp
< len
; tmp
++)
1368 command
[len
] = '\0';
1373 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1375 /* We didn't find the command in the entered case, so lower case it
1378 if (!*cmd
|| nfound
== 0)
1380 for (tmp
= 0; tmp
< len
; tmp
++)
1382 char x
= command
[tmp
];
1383 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1385 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1388 if (*cmd
== (struct cmd_list_element
*) -1)
1390 return 0; /* ambiguous */
1394 return 0; /* nothing found */
1397 if ((*cmd
)->cmd_pointer
)
1399 /* cmd was actually an alias, we note that an alias was used
1400 (by assigning *alais) and we set *cmd.
1403 *cmd
= (*cmd
)->cmd_pointer
;
1405 *prefix_cmd
= prev_cmd
;
1407 if ((*cmd
)->prefixlist
)
1408 cur_list
= *(*cmd
)->prefixlist
;
1416 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1418 /* Return a vector of char pointers which point to the different
1419 possible completions in LIST of TEXT.
1421 WORD points in the same buffer as TEXT, and completions should be
1422 returned relative to this position. For example, suppose TEXT is "foo"
1423 and we want to complete to "foobar". If WORD is "oo", return
1424 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1427 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1429 struct cmd_list_element
*ptr
;
1431 int sizeof_matchlist
;
1433 int textlen
= strlen (text
);
1435 sizeof_matchlist
= 10;
1436 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1439 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1440 if (!strncmp (ptr
->name
, text
, textlen
)
1441 && !ptr
->abbrev_flag
1443 || ptr
->prefixlist
))
1445 if (matches
== sizeof_matchlist
)
1447 sizeof_matchlist
*= 2;
1448 matchlist
= (char **) xrealloc ((char *) matchlist
,
1450 * sizeof (char *)));
1453 matchlist
[matches
] = (char *)
1454 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1456 strcpy (matchlist
[matches
], ptr
->name
);
1457 else if (word
> text
)
1459 /* Return some portion of ptr->name. */
1460 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1464 /* Return some of text plus ptr->name. */
1465 strncpy (matchlist
[matches
], word
, text
- word
);
1466 matchlist
[matches
][text
- word
] = '\0';
1467 strcat (matchlist
[matches
], ptr
->name
);
1479 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1480 * sizeof (char *)));
1481 matchlist
[matches
] = (char *) 0;
1487 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1489 /* Return a vector of char pointers which point to the different
1490 possible completions in CMD of TEXT.
1492 WORD points in the same buffer as TEXT, and completions should be
1493 returned relative to this position. For example, suppose TEXT is "foo"
1494 and we want to complete to "foobar". If WORD is "oo", return
1495 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1498 complete_on_enum (const char *enumlist
[],
1503 int sizeof_matchlist
;
1505 int textlen
= strlen (text
);
1509 sizeof_matchlist
= 10;
1510 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1513 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1514 if (strncmp (name
, text
, textlen
) == 0)
1516 if (matches
== sizeof_matchlist
)
1518 sizeof_matchlist
*= 2;
1519 matchlist
= (char **) xrealloc ((char *) matchlist
,
1521 * sizeof (char *)));
1524 matchlist
[matches
] = (char *)
1525 xmalloc (strlen (word
) + strlen (name
) + 1);
1527 strcpy (matchlist
[matches
], name
);
1528 else if (word
> text
)
1530 /* Return some portion of name. */
1531 strcpy (matchlist
[matches
], name
+ (word
- text
));
1535 /* Return some of text plus name. */
1536 strncpy (matchlist
[matches
], word
, text
- word
);
1537 matchlist
[matches
][text
- word
] = '\0';
1538 strcat (matchlist
[matches
], name
);
1550 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1551 * sizeof (char *)));
1552 matchlist
[matches
] = (char *) 0;
1559 /* check function pointer */
1561 cmd_func_p (struct cmd_list_element
*cmd
)
1563 return (cmd
->func
!= NULL
);
1567 /* call the command function */
1569 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1571 if (cmd_func_p (cmd
))
1572 (*cmd
->func
) (cmd
, args
, from_tty
);
1574 error ("Invalid command");