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_no_selected_thread_ok (struct cmd_list_element
*cmd
)
111 cmd
->flags
|= CMD_NO_SELECTED_THREAD_OK
;
115 get_cmd_no_selected_thread_ok (struct cmd_list_element
*cmd
)
117 return cmd
->flags
& CMD_NO_SELECTED_THREAD_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 struct cmd_list_element
*set_result
;
544 add_setshow_cmd_full (name
, class, var_optional_filename
, var
,
545 set_doc
, show_doc
, help_doc
,
550 set_cmd_completer (set_result
, filename_completer
);
554 /* Add element named NAME to both the set and show command LISTs (the
555 list for set/show or some sublist thereof). CLASS is as in
556 add_cmd. VAR is address of the variable which will contain the
557 value. SET_DOC and SHOW_DOC are the documentation strings. */
559 add_setshow_integer_cmd (char *name
, enum command_class
class,
561 const char *set_doc
, const char *show_doc
,
562 const char *help_doc
,
563 cmd_sfunc_ftype
*set_func
,
564 show_value_ftype
*show_func
,
565 struct cmd_list_element
**set_list
,
566 struct cmd_list_element
**show_list
)
568 add_setshow_cmd_full (name
, class, var_integer
, var
,
569 set_doc
, show_doc
, help_doc
,
575 /* Add element named NAME to both the set and show command LISTs (the
576 list for set/show or some sublist thereof). CLASS is as in
577 add_cmd. VAR is address of the variable which will contain the
578 value. SET_DOC and SHOW_DOC are the documentation strings. */
580 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
582 const char *set_doc
, const char *show_doc
,
583 const char *help_doc
,
584 cmd_sfunc_ftype
*set_func
,
585 show_value_ftype
*show_func
,
586 struct cmd_list_element
**set_list
,
587 struct cmd_list_element
**show_list
)
589 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
590 set_doc
, show_doc
, help_doc
,
596 /* Add element named NAME to both the set and show command LISTs (the
597 list for set/show or some sublist thereof). CLASS is as in
598 add_cmd. VAR is address of the variable which will contain the
599 value. SET_DOC and SHOW_DOC are the documentation strings. */
601 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
603 const char *set_doc
, const char *show_doc
,
604 const char *help_doc
,
605 cmd_sfunc_ftype
*set_func
,
606 show_value_ftype
*show_func
,
607 struct cmd_list_element
**set_list
,
608 struct cmd_list_element
**show_list
)
610 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
611 set_doc
, show_doc
, help_doc
,
617 /* Remove the command named NAME from the command list. */
620 delete_cmd (char *name
, struct cmd_list_element
**list
)
622 struct cmd_list_element
*c
;
623 struct cmd_list_element
*p
;
625 while (*list
&& strcmp ((*list
)->name
, name
) == 0)
627 if ((*list
)->hookee_pre
)
628 (*list
)->hookee_pre
->hook_pre
= 0; /* Hook slips out of its mouth */
629 if ((*list
)->hookee_post
)
630 (*list
)->hookee_post
->hook_post
= 0; /* Hook slips out of its bottom */
637 for (c
= *list
; c
->next
;)
639 if (strcmp (c
->next
->name
, name
) == 0)
641 if (c
->next
->hookee_pre
)
642 c
->next
->hookee_pre
->hook_pre
= 0; /* hooked cmd gets away. */
643 if (c
->next
->hookee_post
)
644 c
->next
->hookee_post
->hook_post
= 0; /* remove post hook */
645 /* :( no fishing metaphore */
655 /* Shorthands to the commands above. */
657 /* Add an element to the list of info subcommands. */
659 struct cmd_list_element
*
660 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
662 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
665 /* Add an alias to the list of info subcommands. */
667 struct cmd_list_element
*
668 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
670 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
673 /* Add an element to the list of commands. */
675 struct cmd_list_element
*
676 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
679 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
682 /* Add an alias or abbreviation command to the list of commands. */
684 struct cmd_list_element
*
685 add_com_alias (char *name
, char *oldname
, enum command_class
class,
688 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
691 /* Recursively walk the commandlist structures, and print out the
692 documentation of commands that match our regex in either their
693 name, or their documentation.
696 apropos_cmd (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
697 struct re_pattern_buffer
*regex
, char *prefix
)
699 struct cmd_list_element
*c
;
700 int returnvalue
=1; /*Needed to avoid double printing*/
701 /* Walk through the commands */
702 for (c
=commandlist
;c
;c
=c
->next
)
706 /* Try to match against the name*/
707 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
708 if (returnvalue
>= 0)
710 print_help_for_command (c
, prefix
,
711 0 /* don't recurse */, stream
);
714 if (c
->doc
!= NULL
&& returnvalue
!= 0)
716 /* Try to match against documentation */
717 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
719 print_help_for_command (c
, prefix
,
720 0 /* don't recurse */, stream
);
723 /* Check if this command has subcommands */
724 if (c
->prefixlist
!= NULL
)
726 /* Recursively call ourselves on the subcommand list,
727 passing the right prefix in.
729 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
734 /* This command really has to deal with two things:
735 * 1) I want documentation on *this string* (usually called by
736 * "help commandname").
737 * 2) I want documentation on *this list* (usually called by
738 * giving a command that requires subcommands. Also called by saying
741 * I am going to split this into two seperate comamnds, help_cmd and
746 help_cmd (char *command
, struct ui_file
*stream
)
748 struct cmd_list_element
*c
;
749 extern struct cmd_list_element
*cmdlist
;
753 help_list (cmdlist
, "", all_classes
, stream
);
757 if (strcmp (command
, "all") == 0)
763 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
768 /* There are three cases here.
769 If c->prefixlist is nonzero, we have a prefix command.
770 Print its documentation, then list its subcommands.
772 If c->func is non NULL, we really have a command. Print its
773 documentation and return.
775 If c->func is NULL, we have a class name. Print its
776 documentation (as if it were a command) and then set class to the
777 number of this class so that the commands in the class will be
780 fputs_filtered (c
->doc
, stream
);
781 fputs_filtered ("\n", stream
);
783 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
785 fprintf_filtered (stream
, "\n");
787 /* If this is a prefix command, print it's subcommands */
789 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
791 /* If this is a class name, print all of the commands in the class */
793 help_list (cmdlist
, "", c
->class, stream
);
795 if (c
->hook_pre
|| c
->hook_post
)
796 fprintf_filtered (stream
,
797 "\nThis command has a hook (or hooks) defined:\n");
800 fprintf_filtered (stream
,
801 "\tThis command is run after : %s (pre hook)\n",
804 fprintf_filtered (stream
,
805 "\tThis command is run before : %s (post hook)\n",
810 * Get a specific kind of help on a command list.
813 * CMDTYPE is the prefix to use in the title string.
814 * CLASS is the class with which to list the nodes of this list (see
815 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
816 * everything, ALL_CLASSES for just classes, and non-negative for only things
817 * in a specific class.
818 * and STREAM is the output stream on which to print things.
819 * If you call this routine with a class >= 0, it recurses.
822 help_list (struct cmd_list_element
*list
, char *cmdtype
,
823 enum command_class
class, struct ui_file
*stream
)
826 char *cmdtype1
, *cmdtype2
;
828 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
829 len
= strlen (cmdtype
);
830 cmdtype1
= (char *) alloca (len
+ 1);
832 cmdtype2
= (char *) alloca (len
+ 4);
837 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
839 strncpy (cmdtype2
, cmdtype
, len
- 1);
840 strcpy (cmdtype2
+ len
- 1, " sub");
843 if (class == all_classes
)
844 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
846 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
848 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
850 if (class == all_classes
)
852 fprintf_filtered (stream
, "\n\
853 Type \"help%s\" followed by a class name for a list of commands in ",
856 fprintf_filtered (stream
, "that class.");
858 fprintf_filtered (stream
, "\n\
859 Type \"help all\" for the list of all commands.");
862 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
865 fputs_filtered ("for ", stream
);
867 fputs_filtered ("full ", stream
);
869 fputs_filtered ("documentation.\n", stream
);
870 fputs_filtered ("Type \"apropos word\" to search "
871 "for commands related to \"word\".\n", stream
);
872 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
877 help_all (struct ui_file
*stream
)
879 struct cmd_list_element
*c
;
880 extern struct cmd_list_element
*cmdlist
;
881 int seen_unclassified
= 0;
883 for (c
= cmdlist
; c
; c
= c
->next
)
887 /* If this is a class name, print all of the commands in the class */
891 fprintf_filtered (stream
, "\nCommand class: %s\n\n", c
->name
);
892 help_cmd_list (cmdlist
, c
->class, "", 1, stream
);
896 /* While it's expected that all commands are in some class,
897 as a safety measure, we'll print commands outside of any
900 for (c
= cmdlist
; c
; c
= c
->next
)
905 if (c
->class == no_class
)
907 if (!seen_unclassified
)
909 fprintf_filtered (stream
, "\nUnclassified commands\n\n");
910 seen_unclassified
= 1;
912 print_help_for_command (c
, "", 1, stream
);
918 /* Print only the first line of STR on STREAM. */
920 print_doc_line (struct ui_file
*stream
, char *str
)
922 static char *line_buffer
= 0;
923 static int line_size
;
929 line_buffer
= (char *) xmalloc (line_size
);
933 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
935 if (p
- str
> line_size
- 1)
937 line_size
= p
- str
+ 1;
939 line_buffer
= (char *) xmalloc (line_size
);
941 strncpy (line_buffer
, str
, p
- str
);
942 line_buffer
[p
- str
] = '\0';
943 if (islower (line_buffer
[0]))
944 line_buffer
[0] = toupper (line_buffer
[0]);
945 ui_out_text (uiout
, line_buffer
);
948 /* Print one-line help for command C.
949 If RECURSE is non-zero, also print one-line descriptions
950 of all prefixed subcommands. */
952 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
953 struct ui_file
*stream
)
955 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
956 print_doc_line (stream
, c
->doc
);
957 fputs_filtered ("\n", stream
);
960 && c
->prefixlist
!= 0
961 && c
->abbrev_flag
== 0)
962 /* Subcommands of a prefix command typically have 'all_commands'
963 as class. If we pass CLASS to recursive invocation,
964 most often we won't see anything. */
965 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 1, stream
);
969 * Implement a help command on command list LIST.
970 * RECURSE should be non-zero if this should be done recursively on
971 * all sublists of LIST.
972 * PREFIX is the prefix to print before each command name.
973 * STREAM is the stream upon which the output should be written.
975 * A non-negative class number to list only commands in that
977 * ALL_COMMANDS to list all commands in list.
978 * ALL_CLASSES to list all classes in list.
980 * Note that RECURSE will be active on *all* sublists, not just the
981 * ones selected by the criteria above (ie. the selection mechanism
982 * is at the low level, not the high-level).
985 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
986 char *prefix
, int recurse
, struct ui_file
*stream
)
988 struct cmd_list_element
*c
;
990 for (c
= list
; c
; c
= c
->next
)
992 if (c
->abbrev_flag
== 0 &&
993 (class == all_commands
994 || (class == all_classes
&& c
->func
== NULL
)
995 || (class == c
->class && c
->func
!= NULL
)))
997 print_help_for_command (c
, prefix
, recurse
, stream
);
1003 /* Search the input clist for 'command'. Return the command if
1004 found (or NULL if not), and return the number of commands
1007 static struct cmd_list_element
*
1008 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
1009 int ignore_help_classes
, int *nfound
)
1011 struct cmd_list_element
*found
, *c
;
1013 found
= (struct cmd_list_element
*) NULL
;
1015 for (c
= clist
; c
; c
= c
->next
)
1016 if (!strncmp (command
, c
->name
, len
)
1017 && (!ignore_help_classes
|| c
->func
))
1021 if (c
->name
[len
] == '\0')
1031 find_command_name_length (const char *text
)
1033 const char *p
= text
;
1035 /* Treating underscores as part of command words is important
1036 so that "set args_foo()" doesn't get interpreted as
1037 "set args _foo()". */
1038 /* Some characters are only used for TUI specific commands. However, they
1039 are always allowed for the sake of consistency.
1040 The XDB compatibility characters are only allowed when using the right
1041 mode because they clash with other GDB commands - specifically '/' is
1042 used as a suffix for print, examine and display.
1043 Note that this is larger than the character set allowed when creating
1044 user-defined commands. */
1045 while (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1046 /* Characters used by TUI specific commands. */
1047 *p
== '+' || *p
== '<' || *p
== '>' || *p
== '$' ||
1048 /* Characters used for XDB compatibility. */
1049 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')))
1055 /* This routine takes a line of TEXT and a CLIST in which to start the
1056 lookup. When it returns it will have incremented the text pointer past
1057 the section of text it matched, set *RESULT_LIST to point to the list in
1058 which the last word was matched, and will return a pointer to the cmd
1059 list element which the text matches. It will return NULL if no match at
1060 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1061 matches are possible; in this case *RESULT_LIST will be set to point to
1062 the list in which there are ambiguous choices (and *TEXT will be set to
1063 the ambiguous text string).
1065 If the located command was an abbreviation, this routine returns the base
1066 command of the abbreviation.
1068 It does no error reporting whatsoever; control will always return
1069 to the superior routine.
1071 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1072 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1073 if no prefix command was ever found. For example, in the case of "info a",
1074 "info" matches without ambiguity, but "a" could be "args" or "address", so
1075 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1076 RESULT_LIST should not be interpeted as a pointer to the beginning of a
1077 list; it simply points to a specific command. In the case of an ambiguous
1078 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1079 "info t" can be "info types" or "info target"; upon return *TEXT has been
1080 advanced past "info ").
1082 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1083 affect the operation).
1085 This routine does *not* modify the text pointed to by TEXT.
1087 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1088 are actually help classes rather than commands (i.e. the function field of
1089 the struct cmd_list_element is NULL). */
1091 struct cmd_list_element
*
1092 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
1093 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1096 int len
, tmp
, nfound
;
1097 struct cmd_list_element
*found
, *c
;
1100 while (**text
== ' ' || **text
== '\t')
1103 /* Identify the name of the command. */
1104 len
= find_command_name_length (*text
);
1106 /* If nothing but whitespace, return 0. */
1110 /* *text and p now bracket the first command word to lookup (and
1111 it's length is len). We copy this into a local temporary */
1114 command
= (char *) alloca (len
+ 1);
1115 memcpy (command
, *text
, len
);
1116 command
[len
] = '\0';
1121 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1124 ** We didn't find the command in the entered case, so lower case it
1125 ** and search again.
1127 if (!found
|| nfound
== 0)
1129 for (tmp
= 0; tmp
< len
; tmp
++)
1131 char x
= command
[tmp
];
1132 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1134 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1137 /* If nothing matches, we have a simple failure. */
1143 if (result_list
!= NULL
)
1144 /* Will be modified in calling routine
1145 if we know what the prefix command is. */
1147 return (struct cmd_list_element
*) -1; /* Ambiguous. */
1150 /* We've matched something on this list. Move text pointer forward. */
1154 if (found
->cmd_pointer
)
1156 /* We drop the alias (abbreviation) in favor of the command it is
1157 pointing to. If the alias is deprecated, though, we need to
1158 warn the user about it before we drop it. Note that while we
1159 are warning about the alias, we may also warn about the command
1160 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1163 if (found
->flags
& DEPRECATED_WARN_USER
)
1164 deprecated_cmd_warning (&line
);
1165 found
= found
->cmd_pointer
;
1167 /* If we found a prefix command, keep looking. */
1169 if (found
->prefixlist
)
1171 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1172 ignore_help_classes
);
1175 /* Didn't find anything; this is as far as we got. */
1176 if (result_list
!= NULL
)
1177 *result_list
= clist
;
1180 else if (c
== (struct cmd_list_element
*) -1)
1182 /* We've gotten this far properly, but the next step
1183 is ambiguous. We need to set the result list to the best
1184 we've found (if an inferior hasn't already set it). */
1185 if (result_list
!= NULL
)
1187 /* This used to say *result_list = *found->prefixlist
1188 If that was correct, need to modify the documentation
1189 at the top of this function to clarify what is supposed
1191 *result_list
= found
;
1202 if (result_list
!= NULL
)
1203 *result_list
= clist
;
1208 /* All this hair to move the space to the front of cmdtype */
1211 undef_cmd_error (char *cmdtype
, char *q
)
1213 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1216 *cmdtype
? " " : "",
1217 (int) strlen (cmdtype
) - 1,
1221 /* Look up the contents of *LINE as a command in the command list LIST.
1222 LIST is a chain of struct cmd_list_element's.
1223 If it is found, return the struct cmd_list_element for that command
1224 and update *LINE to point after the command name, at the first argument.
1225 If not found, call error if ALLOW_UNKNOWN is zero
1226 otherwise (or if error returns) return zero.
1227 Call error if specified command is ambiguous,
1228 unless ALLOW_UNKNOWN is negative.
1229 CMDTYPE precedes the word "command" in the error message.
1231 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1232 elements which are actually help classes rather than commands (i.e.
1233 the function field of the struct cmd_list_element is 0). */
1235 struct cmd_list_element
*
1236 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1237 int allow_unknown
, int ignore_help_classes
)
1239 struct cmd_list_element
*last_list
= 0;
1240 struct cmd_list_element
*c
;
1242 /* Note: Do not remove trailing whitespace here because this
1243 would be wrong for complete_command. Jim Kingdon */
1246 error (_("Lack of needed %scommand"), cmdtype
);
1248 c
= lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1255 int len
= find_command_name_length (*line
);
1257 q
= (char *) alloca (len
+ 1);
1258 strncpy (q
, *line
, len
);
1260 undef_cmd_error (cmdtype
, q
);
1265 else if (c
== (struct cmd_list_element
*) -1)
1267 /* Ambigous. Local values should be off prefixlist or called
1269 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1271 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1272 struct cmd_list_element
*local_list
=
1273 (last_list
? *(last_list
->prefixlist
) : list
);
1275 if (local_allow_unknown
< 0)
1278 return last_list
; /* Found something. */
1280 return 0; /* Found nothing. */
1284 /* Report as error. */
1289 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1290 && (*line
)[amb_len
] != '\t');
1295 for (c
= local_list
; c
; c
= c
->next
)
1296 if (!strncmp (*line
, c
->name
, amb_len
))
1298 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1300 if (strlen (ambbuf
))
1301 strcat (ambbuf
, ", ");
1302 strcat (ambbuf
, c
->name
);
1306 strcat (ambbuf
, "..");
1310 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1312 return 0; /* lint */
1317 /* We've got something. It may still not be what the caller
1318 wants (if this command *needs* a subcommand). */
1319 while (**line
== ' ' || **line
== '\t')
1322 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1323 undef_cmd_error (c
->prefixname
, *line
);
1325 /* Seems to be what he wants. Return it. */
1331 /* We are here presumably because an alias or command in *TEXT is
1332 deprecated and a warning message should be generated. This function
1333 decodes *TEXT and potentially generates a warning message as outlined
1336 Example for 'set endian big' which has a fictitious alias 'seb'.
1338 If alias wasn't used in *TEXT, and the command is deprecated:
1339 "warning: 'set endian big' is deprecated."
1341 If alias was used, and only the alias is deprecated:
1342 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1344 If alias was used and command is deprecated (regardless of whether the
1345 alias itself is deprecated:
1347 "warning: 'set endian big' (seb) is deprecated."
1349 After the message has been sent, clear the appropriate flags in the
1350 command and/or the alias so the user is no longer bothered.
1354 deprecated_cmd_warning (char **text
)
1356 struct cmd_list_element
*alias
= NULL
;
1357 struct cmd_list_element
*prefix_cmd
= NULL
;
1358 struct cmd_list_element
*cmd
= NULL
;
1359 struct cmd_list_element
*c
;
1362 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1363 /* return if text doesn't evaluate to a command */
1366 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1367 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1368 /* return if nothing is deprecated */
1371 printf_filtered ("Warning:");
1373 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1374 printf_filtered (" '%s', an alias for the", alias
->name
);
1376 printf_filtered (" command '");
1379 printf_filtered ("%s", prefix_cmd
->prefixname
);
1381 printf_filtered ("%s", cmd
->name
);
1383 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1384 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1386 printf_filtered ("' is deprecated.\n");
1389 /* if it is only the alias that is deprecated, we want to indicate the
1390 new alias, otherwise we'll indicate the new command */
1392 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1394 if (alias
->replacement
)
1395 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1397 printf_filtered ("No alternative known.\n\n");
1401 if (cmd
->replacement
)
1402 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1404 printf_filtered ("No alternative known.\n\n");
1407 /* We've warned you, now we'll keep quiet */
1409 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1411 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1416 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1417 Return 1 on success, 0 on failure.
1419 If LINE refers to an alias, *alias will point to that alias.
1421 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1422 command) set *prefix_cmd.
1424 Set *cmd to point to the command LINE indicates.
1426 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1427 exist, they are NULL when we return.
1431 lookup_cmd_composition (char *text
,
1432 struct cmd_list_element
**alias
,
1433 struct cmd_list_element
**prefix_cmd
,
1434 struct cmd_list_element
**cmd
)
1437 int len
, tmp
, nfound
;
1438 struct cmd_list_element
*cur_list
;
1439 struct cmd_list_element
*prev_cmd
;
1448 /* Go through as many command lists as we need to
1449 to find the command TEXT refers to. */
1453 while (*text
== ' ' || *text
== '\t')
1456 /* Identify the name of the command. */
1457 len
= find_command_name_length (text
);
1459 /* If nothing but whitespace, return. */
1463 /* text is the start of the first command word to lookup (and
1464 it's length is len). We copy this into a local temporary */
1466 command
= (char *) alloca (len
+ 1);
1467 memcpy (command
, text
, len
);
1468 command
[len
] = '\0';
1473 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1475 /* We didn't find the command in the entered case, so lower case it
1478 if (!*cmd
|| nfound
== 0)
1480 for (tmp
= 0; tmp
< len
; tmp
++)
1482 char x
= command
[tmp
];
1483 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1485 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1488 if (*cmd
== (struct cmd_list_element
*) -1)
1490 return 0; /* ambiguous */
1494 return 0; /* nothing found */
1497 if ((*cmd
)->cmd_pointer
)
1499 /* cmd was actually an alias, we note that an alias was used
1500 (by assigning *alais) and we set *cmd.
1503 *cmd
= (*cmd
)->cmd_pointer
;
1505 *prefix_cmd
= prev_cmd
;
1507 if ((*cmd
)->prefixlist
)
1508 cur_list
= *(*cmd
)->prefixlist
;
1516 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1518 /* Return a vector of char pointers which point to the different
1519 possible completions in LIST of TEXT.
1521 WORD points in the same buffer as TEXT, and completions should be
1522 returned relative to this position. For example, suppose TEXT is "foo"
1523 and we want to complete to "foobar". If WORD is "oo", return
1524 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1527 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1529 struct cmd_list_element
*ptr
;
1531 int sizeof_matchlist
;
1533 int textlen
= strlen (text
);
1535 sizeof_matchlist
= 10;
1536 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1539 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1540 if (!strncmp (ptr
->name
, text
, textlen
)
1541 && !ptr
->abbrev_flag
1543 || ptr
->prefixlist
))
1545 if (matches
== sizeof_matchlist
)
1547 sizeof_matchlist
*= 2;
1548 matchlist
= (char **) xrealloc ((char *) matchlist
,
1550 * sizeof (char *)));
1553 matchlist
[matches
] = (char *)
1554 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1556 strcpy (matchlist
[matches
], ptr
->name
);
1557 else if (word
> text
)
1559 /* Return some portion of ptr->name. */
1560 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1564 /* Return some of text plus ptr->name. */
1565 strncpy (matchlist
[matches
], word
, text
- word
);
1566 matchlist
[matches
][text
- word
] = '\0';
1567 strcat (matchlist
[matches
], ptr
->name
);
1579 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1580 * sizeof (char *)));
1581 matchlist
[matches
] = (char *) 0;
1587 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1589 /* Return a vector of char pointers which point to the different
1590 possible completions in CMD of TEXT.
1592 WORD points in the same buffer as TEXT, and completions should be
1593 returned relative to this position. For example, suppose TEXT is "foo"
1594 and we want to complete to "foobar". If WORD is "oo", return
1595 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1598 complete_on_enum (const char *enumlist
[],
1603 int sizeof_matchlist
;
1605 int textlen
= strlen (text
);
1609 sizeof_matchlist
= 10;
1610 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1613 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1614 if (strncmp (name
, text
, textlen
) == 0)
1616 if (matches
== sizeof_matchlist
)
1618 sizeof_matchlist
*= 2;
1619 matchlist
= (char **) xrealloc ((char *) matchlist
,
1621 * sizeof (char *)));
1624 matchlist
[matches
] = (char *)
1625 xmalloc (strlen (word
) + strlen (name
) + 1);
1627 strcpy (matchlist
[matches
], name
);
1628 else if (word
> text
)
1630 /* Return some portion of name. */
1631 strcpy (matchlist
[matches
], name
+ (word
- text
));
1635 /* Return some of text plus name. */
1636 strncpy (matchlist
[matches
], word
, text
- word
);
1637 matchlist
[matches
][text
- word
] = '\0';
1638 strcat (matchlist
[matches
], name
);
1650 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1651 * sizeof (char *)));
1652 matchlist
[matches
] = (char *) 0;
1659 /* check function pointer */
1661 cmd_func_p (struct cmd_list_element
*cmd
)
1663 return (cmd
->func
!= NULL
);
1667 /* call the command function */
1669 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1671 if (cmd_func_p (cmd
))
1672 (*cmd
->func
) (cmd
, args
, from_tty
);
1674 error (_("Invalid command"));