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"
26 #include "completer.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
,
334 cmd_sfunc_ftype
*set_func
,
335 show_value_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
;
346 if (help_doc
!= NULL
)
348 full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
349 full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
353 full_set_doc
= xstrdup (set_doc
);
354 full_show_doc
= xstrdup (show_doc
);
356 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
357 full_set_doc
, set_list
);
358 if (set_func
!= NULL
)
359 set_cmd_sfunc (set
, set_func
);
360 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
361 full_show_doc
, show_list
);
362 show
->show_value_func
= show_func
;
364 if (set_result
!= NULL
)
366 if (show_result
!= NULL
)
370 struct cmd_list_element
*
371 deprecated_add_set_cmd (char *name
,
372 enum command_class
class,
376 struct cmd_list_element
**list
)
378 return add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
, doc
, list
);
381 /* Add element named NAME to command list LIST (the list for set or
382 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
383 of strings which may follow NAME. VAR is address of the variable
384 which will contain the matching string (from ENUMLIST). */
387 add_setshow_enum_cmd (char *name
,
388 enum command_class
class,
389 const char *enumlist
[],
392 const char *show_doc
,
393 const char *help_doc
,
394 cmd_sfunc_ftype
*set_func
,
395 show_value_ftype
*show_func
,
396 struct cmd_list_element
**set_list
,
397 struct cmd_list_element
**show_list
)
399 struct cmd_list_element
*c
;
400 add_setshow_cmd_full (name
, class, var_enum
, var
,
401 set_doc
, show_doc
, help_doc
,
408 /* Add an auto-boolean command named NAME to both the set and show
409 command list lists. CLASS is as in add_cmd. VAR is address of the
410 variable which will contain the value. DOC is the documentation
411 string. FUNC is the corresponding callback. */
413 add_setshow_auto_boolean_cmd (char *name
,
414 enum command_class
class,
415 enum auto_boolean
*var
,
416 const char *set_doc
, const char *show_doc
,
417 const char *help_doc
,
418 cmd_sfunc_ftype
*set_func
,
419 show_value_ftype
*show_func
,
420 struct cmd_list_element
**set_list
,
421 struct cmd_list_element
**show_list
)
423 static const char *auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
424 struct cmd_list_element
*c
;
425 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
426 set_doc
, show_doc
, help_doc
,
430 c
->enums
= auto_boolean_enums
;
433 /* Add element named NAME to both the set and show command LISTs (the
434 list for set/show or some sublist thereof). CLASS is as in
435 add_cmd. VAR is address of the variable which will contain the
436 value. SET_DOC and SHOW_DOC are the documentation strings. */
438 add_setshow_boolean_cmd (char *name
, enum command_class
class, int *var
,
439 const char *set_doc
, const char *show_doc
,
440 const char *help_doc
,
441 cmd_sfunc_ftype
*set_func
,
442 show_value_ftype
*show_func
,
443 struct cmd_list_element
**set_list
,
444 struct cmd_list_element
**show_list
)
446 static const char *boolean_enums
[] = { "on", "off", NULL
};
447 struct cmd_list_element
*c
;
448 add_setshow_cmd_full (name
, class, var_boolean
, var
,
449 set_doc
, show_doc
, help_doc
,
453 c
->enums
= boolean_enums
;
456 /* Add element named NAME to both the set and show command LISTs (the
457 list for set/show or some sublist thereof). */
459 add_setshow_filename_cmd (char *name
, enum command_class
class,
461 const char *set_doc
, const char *show_doc
,
462 const char *help_doc
,
463 cmd_sfunc_ftype
*set_func
,
464 show_value_ftype
*show_func
,
465 struct cmd_list_element
**set_list
,
466 struct cmd_list_element
**show_list
)
468 struct cmd_list_element
*set_result
;
469 add_setshow_cmd_full (name
, class, var_filename
, var
,
470 set_doc
, show_doc
, help_doc
,
474 set_cmd_completer (set_result
, filename_completer
);
477 /* Add element named NAME to both the set and show command LISTs (the
478 list for set/show or some sublist thereof). */
480 add_setshow_string_cmd (char *name
, enum command_class
class,
482 const char *set_doc
, const char *show_doc
,
483 const char *help_doc
,
484 cmd_sfunc_ftype
*set_func
,
485 show_value_ftype
*show_func
,
486 struct cmd_list_element
**set_list
,
487 struct cmd_list_element
**show_list
)
489 add_setshow_cmd_full (name
, class, var_string
, var
,
490 set_doc
, show_doc
, help_doc
,
496 /* Add element named NAME to both the set and show command LISTs (the
497 list for set/show or some sublist thereof). */
499 add_setshow_string_noescape_cmd (char *name
, enum command_class
class,
501 const char *set_doc
, const char *show_doc
,
502 const char *help_doc
,
503 cmd_sfunc_ftype
*set_func
,
504 show_value_ftype
*show_func
,
505 struct cmd_list_element
**set_list
,
506 struct cmd_list_element
**show_list
)
508 add_setshow_cmd_full (name
, class, var_string_noescape
, var
,
509 set_doc
, show_doc
, help_doc
,
515 /* Add element named NAME to both the set and show command LISTs (the
516 list for set/show or some sublist thereof). */
518 add_setshow_optional_filename_cmd (char *name
, enum command_class
class,
520 const char *set_doc
, const char *show_doc
,
521 const char *help_doc
,
522 cmd_sfunc_ftype
*set_func
,
523 show_value_ftype
*show_func
,
524 struct cmd_list_element
**set_list
,
525 struct cmd_list_element
**show_list
)
527 add_setshow_cmd_full (name
, class, var_optional_filename
, var
,
528 set_doc
, show_doc
, help_doc
,
534 /* Add element named NAME to both the set and show command LISTs (the
535 list for set/show or some sublist thereof). CLASS is as in
536 add_cmd. VAR is address of the variable which will contain the
537 value. SET_DOC and SHOW_DOC are the documentation strings. */
539 add_setshow_integer_cmd (char *name
, enum command_class
class,
541 const char *set_doc
, const char *show_doc
,
542 const char *help_doc
,
543 cmd_sfunc_ftype
*set_func
,
544 show_value_ftype
*show_func
,
545 struct cmd_list_element
**set_list
,
546 struct cmd_list_element
**show_list
)
548 add_setshow_cmd_full (name
, class, var_integer
, var
,
549 set_doc
, show_doc
, help_doc
,
555 /* Add element named NAME to both the set and show command LISTs (the
556 list for set/show or some sublist thereof). CLASS is as in
557 add_cmd. VAR is address of the variable which will contain the
558 value. SET_DOC and SHOW_DOC are the documentation strings. */
560 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
562 const char *set_doc
, const char *show_doc
,
563 const char *help_doc
,
564 cmd_sfunc_ftype
*set_func
,
565 show_value_ftype
*show_func
,
566 struct cmd_list_element
**set_list
,
567 struct cmd_list_element
**show_list
)
569 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
570 set_doc
, show_doc
, help_doc
,
576 /* Add element named NAME to both the set and show command LISTs (the
577 list for set/show or some sublist thereof). CLASS is as in
578 add_cmd. VAR is address of the variable which will contain the
579 value. SET_DOC and SHOW_DOC are the documentation strings. */
581 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
583 const char *set_doc
, const char *show_doc
,
584 const char *help_doc
,
585 cmd_sfunc_ftype
*set_func
,
586 show_value_ftype
*show_func
,
587 struct cmd_list_element
**set_list
,
588 struct cmd_list_element
**show_list
)
590 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
591 set_doc
, show_doc
, help_doc
,
597 /* Remove the command named NAME from the command list. */
600 delete_cmd (char *name
, struct cmd_list_element
**list
)
602 struct cmd_list_element
*c
;
603 struct cmd_list_element
*p
;
605 while (*list
&& strcmp ((*list
)->name
, name
) == 0)
607 if ((*list
)->hookee_pre
)
608 (*list
)->hookee_pre
->hook_pre
= 0; /* Hook slips out of its mouth */
609 if ((*list
)->hookee_post
)
610 (*list
)->hookee_post
->hook_post
= 0; /* Hook slips out of its bottom */
617 for (c
= *list
; c
->next
;)
619 if (strcmp (c
->next
->name
, name
) == 0)
621 if (c
->next
->hookee_pre
)
622 c
->next
->hookee_pre
->hook_pre
= 0; /* hooked cmd gets away. */
623 if (c
->next
->hookee_post
)
624 c
->next
->hookee_post
->hook_post
= 0; /* remove post hook */
625 /* :( no fishing metaphore */
635 /* Shorthands to the commands above. */
637 /* Add an element to the list of info subcommands. */
639 struct cmd_list_element
*
640 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
642 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
645 /* Add an alias to the list of info subcommands. */
647 struct cmd_list_element
*
648 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
650 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
653 /* Add an element to the list of commands. */
655 struct cmd_list_element
*
656 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
659 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
662 /* Add an alias or abbreviation command to the list of commands. */
664 struct cmd_list_element
*
665 add_com_alias (char *name
, char *oldname
, enum command_class
class,
668 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
671 /* Recursively walk the commandlist structures, and print out the
672 documentation of commands that match our regex in either their
673 name, or their documentation.
676 apropos_cmd (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
677 struct re_pattern_buffer
*regex
, char *prefix
)
679 struct cmd_list_element
*c
;
680 int returnvalue
=1; /*Needed to avoid double printing*/
681 /* Walk through the commands */
682 for (c
=commandlist
;c
;c
=c
->next
)
686 /* Try to match against the name*/
687 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
688 if (returnvalue
>= 0)
690 /* Stolen from help_cmd_list. We don't directly use
691 * help_cmd_list because it doesn't let us print out
694 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
695 print_doc_line (stream
, c
->doc
);
696 fputs_filtered ("\n", stream
);
697 returnvalue
=0; /*Set this so we don't print it again.*/
700 if (c
->doc
!= NULL
&& returnvalue
!= 0)
702 /* Try to match against documentation */
703 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
705 /* Stolen from help_cmd_list. We don't directly use
706 * help_cmd_list because it doesn't let us print out
709 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
710 print_doc_line (stream
, c
->doc
);
711 fputs_filtered ("\n", stream
);
714 /* Check if this command has subcommands */
715 if (c
->prefixlist
!= NULL
)
717 /* Recursively call ourselves on the subcommand list,
718 passing the right prefix in.
720 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
725 /* This command really has to deal with two things:
726 * 1) I want documentation on *this string* (usually called by
727 * "help commandname").
728 * 2) I want documentation on *this list* (usually called by
729 * giving a command that requires subcommands. Also called by saying
732 * I am going to split this into two seperate comamnds, help_cmd and
737 help_cmd (char *command
, struct ui_file
*stream
)
739 struct cmd_list_element
*c
;
740 extern struct cmd_list_element
*cmdlist
;
744 help_list (cmdlist
, "", all_classes
, stream
);
748 if (strcmp (command
, "all") == 0)
754 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
759 /* There are three cases here.
760 If c->prefixlist is nonzero, we have a prefix command.
761 Print its documentation, then list its subcommands.
763 If c->func is non NULL, we really have a command. Print its
764 documentation and return.
766 If c->func is NULL, we have a class name. Print its
767 documentation (as if it were a command) and then set class to the
768 number of this class so that the commands in the class will be
771 fputs_filtered (c
->doc
, stream
);
772 fputs_filtered ("\n", stream
);
774 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
776 fprintf_filtered (stream
, "\n");
778 /* If this is a prefix command, print it's subcommands */
780 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
782 /* If this is a class name, print all of the commands in the class */
784 help_list (cmdlist
, "", c
->class, stream
);
786 if (c
->hook_pre
|| c
->hook_post
)
787 fprintf_filtered (stream
,
788 "\nThis command has a hook (or hooks) defined:\n");
791 fprintf_filtered (stream
,
792 "\tThis command is run after : %s (pre hook)\n",
795 fprintf_filtered (stream
,
796 "\tThis command is run before : %s (post hook)\n",
801 * Get a specific kind of help on a command list.
804 * CMDTYPE is the prefix to use in the title string.
805 * CLASS is the class with which to list the nodes of this list (see
806 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
807 * everything, ALL_CLASSES for just classes, and non-negative for only things
808 * in a specific class.
809 * and STREAM is the output stream on which to print things.
810 * If you call this routine with a class >= 0, it recurses.
813 help_list (struct cmd_list_element
*list
, char *cmdtype
,
814 enum command_class
class, struct ui_file
*stream
)
817 char *cmdtype1
, *cmdtype2
;
819 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
820 len
= strlen (cmdtype
);
821 cmdtype1
= (char *) alloca (len
+ 1);
823 cmdtype2
= (char *) alloca (len
+ 4);
828 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
830 strncpy (cmdtype2
, cmdtype
, len
- 1);
831 strcpy (cmdtype2
+ len
- 1, " sub");
834 if (class == all_classes
)
835 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
837 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
839 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
841 if (class == all_classes
)
843 fprintf_filtered (stream
, "\n\
844 Type \"help%s\" followed by a class name for a list of commands in ",
847 fprintf_filtered (stream
, "that class.");
850 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
853 fputs_filtered ("for ", stream
);
855 fputs_filtered ("full ", stream
);
857 fputs_filtered ("documentation.\n", stream
);
858 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
863 help_all (struct ui_file
*stream
)
865 struct cmd_list_element
*c
;
866 extern struct cmd_list_element
*cmdlist
;
868 for (c
= cmdlist
; c
; c
= c
->next
)
872 /* If this is a prefix command, print it's subcommands */
874 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 0, stream
);
876 /* If this is a class name, print all of the commands in the class */
877 else if (c
->func
== NULL
)
878 help_cmd_list (cmdlist
, c
->class, "", 0, stream
);
882 /* Print only the first line of STR on STREAM. */
884 print_doc_line (struct ui_file
*stream
, char *str
)
886 static char *line_buffer
= 0;
887 static int line_size
;
893 line_buffer
= (char *) xmalloc (line_size
);
897 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
899 if (p
- str
> line_size
- 1)
901 line_size
= p
- str
+ 1;
903 line_buffer
= (char *) xmalloc (line_size
);
905 strncpy (line_buffer
, str
, p
- str
);
906 line_buffer
[p
- str
] = '\0';
907 if (islower (line_buffer
[0]))
908 line_buffer
[0] = toupper (line_buffer
[0]);
909 ui_out_text (uiout
, line_buffer
);
913 * Implement a help command on command list LIST.
914 * RECURSE should be non-zero if this should be done recursively on
915 * all sublists of LIST.
916 * PREFIX is the prefix to print before each command name.
917 * STREAM is the stream upon which the output should be written.
919 * A non-negative class number to list only commands in that
921 * ALL_COMMANDS to list all commands in list.
922 * ALL_CLASSES to list all classes in list.
924 * Note that RECURSE will be active on *all* sublists, not just the
925 * ones selected by the criteria above (ie. the selection mechanism
926 * is at the low level, not the high-level).
929 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
930 char *prefix
, int recurse
, struct ui_file
*stream
)
932 struct cmd_list_element
*c
;
934 for (c
= list
; c
; c
= c
->next
)
936 if (c
->abbrev_flag
== 0 &&
937 (class == all_commands
938 || (class == all_classes
&& c
->func
== NULL
)
939 || (class == c
->class && c
->func
!= NULL
)))
941 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
942 print_doc_line (stream
, c
->doc
);
943 fputs_filtered ("\n", stream
);
946 && c
->prefixlist
!= 0
947 && c
->abbrev_flag
== 0)
948 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
, 1, stream
);
953 /* Search the input clist for 'command'. Return the command if
954 found (or NULL if not), and return the number of commands
957 static struct cmd_list_element
*
958 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
959 int ignore_help_classes
, int *nfound
)
961 struct cmd_list_element
*found
, *c
;
963 found
= (struct cmd_list_element
*) NULL
;
965 for (c
= clist
; c
; c
= c
->next
)
966 if (!strncmp (command
, c
->name
, len
)
967 && (!ignore_help_classes
|| c
->func
))
971 if (c
->name
[len
] == '\0')
980 /* This routine takes a line of TEXT and a CLIST in which to start the
981 lookup. When it returns it will have incremented the text pointer past
982 the section of text it matched, set *RESULT_LIST to point to the list in
983 which the last word was matched, and will return a pointer to the cmd
984 list element which the text matches. It will return NULL if no match at
985 all was possible. It will return -1 (cast appropriately, ick) if ambigous
986 matches are possible; in this case *RESULT_LIST will be set to point to
987 the list in which there are ambiguous choices (and *TEXT will be set to
988 the ambiguous text string).
990 If the located command was an abbreviation, this routine returns the base
991 command of the abbreviation.
993 It does no error reporting whatsoever; control will always return
994 to the superior routine.
996 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
997 at the prefix_command (ie. the best match) *or* (special case) will be NULL
998 if no prefix command was ever found. For example, in the case of "info a",
999 "info" matches without ambiguity, but "a" could be "args" or "address", so
1000 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1001 RESULT_LIST should not be interpeted as a pointer to the beginning of a
1002 list; it simply points to a specific command. In the case of an ambiguous
1003 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1004 "info t" can be "info types" or "info target"; upon return *TEXT has been
1005 advanced past "info ").
1007 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1008 affect the operation).
1010 This routine does *not* modify the text pointed to by TEXT.
1012 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1013 are actually help classes rather than commands (i.e. the function field of
1014 the struct cmd_list_element is NULL). */
1016 struct cmd_list_element
*
1017 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
1018 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1021 int len
, tmp
, nfound
;
1022 struct cmd_list_element
*found
, *c
;
1025 while (**text
== ' ' || **text
== '\t')
1028 /* Treating underscores as part of command words is important
1029 so that "set args_foo()" doesn't get interpreted as
1030 "set args _foo()". */
1031 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1034 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1037 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1039 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1043 /* If nothing but whitespace, return 0. */
1049 /* *text and p now bracket the first command word to lookup (and
1050 it's length is len). We copy this into a local temporary */
1053 command
= (char *) alloca (len
+ 1);
1054 for (tmp
= 0; tmp
< len
; tmp
++)
1056 char x
= (*text
)[tmp
];
1059 command
[len
] = '\0';
1064 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1067 ** We didn't find the command in the entered case, so lower case it
1068 ** and search again.
1070 if (!found
|| nfound
== 0)
1072 for (tmp
= 0; tmp
< len
; tmp
++)
1074 char x
= command
[tmp
];
1075 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1077 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1080 /* If nothing matches, we have a simple failure. */
1086 if (result_list
!= NULL
)
1087 /* Will be modified in calling routine
1088 if we know what the prefix command is. */
1090 return (struct cmd_list_element
*) -1; /* Ambiguous. */
1093 /* We've matched something on this list. Move text pointer forward. */
1097 if (found
->cmd_pointer
)
1099 /* We drop the alias (abbreviation) in favor of the command it is
1100 pointing to. If the alias is deprecated, though, we need to
1101 warn the user about it before we drop it. Note that while we
1102 are warning about the alias, we may also warn about the command
1103 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1106 if (found
->flags
& DEPRECATED_WARN_USER
)
1107 deprecated_cmd_warning (&line
);
1108 found
= found
->cmd_pointer
;
1110 /* If we found a prefix command, keep looking. */
1112 if (found
->prefixlist
)
1114 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1115 ignore_help_classes
);
1118 /* Didn't find anything; this is as far as we got. */
1119 if (result_list
!= NULL
)
1120 *result_list
= clist
;
1123 else if (c
== (struct cmd_list_element
*) -1)
1125 /* We've gotten this far properly, but the next step
1126 is ambiguous. We need to set the result list to the best
1127 we've found (if an inferior hasn't already set it). */
1128 if (result_list
!= NULL
)
1130 /* This used to say *result_list = *found->prefixlist
1131 If that was correct, need to modify the documentation
1132 at the top of this function to clarify what is supposed
1134 *result_list
= found
;
1145 if (result_list
!= NULL
)
1146 *result_list
= clist
;
1151 /* All this hair to move the space to the front of cmdtype */
1154 undef_cmd_error (char *cmdtype
, char *q
)
1156 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1159 *cmdtype
? " " : "",
1160 (int) strlen (cmdtype
) - 1,
1164 /* Look up the contents of *LINE as a command in the command list LIST.
1165 LIST is a chain of struct cmd_list_element's.
1166 If it is found, return the struct cmd_list_element for that command
1167 and update *LINE to point after the command name, at the first argument.
1168 If not found, call error if ALLOW_UNKNOWN is zero
1169 otherwise (or if error returns) return zero.
1170 Call error if specified command is ambiguous,
1171 unless ALLOW_UNKNOWN is negative.
1172 CMDTYPE precedes the word "command" in the error message.
1174 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1175 elements which are actually help classes rather than commands (i.e.
1176 the function field of the struct cmd_list_element is 0). */
1178 struct cmd_list_element
*
1179 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1180 int allow_unknown
, int ignore_help_classes
)
1182 struct cmd_list_element
*last_list
= 0;
1183 struct cmd_list_element
*c
=
1184 lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1186 /* Note: Do not remove trailing whitespace here because this
1187 would be wrong for complete_command. Jim Kingdon */
1194 error (_("Lack of needed %scommand"), cmdtype
);
1197 char *p
= *line
, *q
;
1199 while (isalnum (*p
) || *p
== '-')
1202 q
= (char *) alloca (p
- *line
+ 1);
1203 strncpy (q
, *line
, p
- *line
);
1204 q
[p
- *line
] = '\0';
1205 undef_cmd_error (cmdtype
, q
);
1211 else if (c
== (struct cmd_list_element
*) -1)
1213 /* Ambigous. Local values should be off prefixlist or called
1215 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1217 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1218 struct cmd_list_element
*local_list
=
1219 (last_list
? *(last_list
->prefixlist
) : list
);
1221 if (local_allow_unknown
< 0)
1224 return last_list
; /* Found something. */
1226 return 0; /* Found nothing. */
1230 /* Report as error. */
1235 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1236 && (*line
)[amb_len
] != '\t');
1241 for (c
= local_list
; c
; c
= c
->next
)
1242 if (!strncmp (*line
, c
->name
, amb_len
))
1244 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1246 if (strlen (ambbuf
))
1247 strcat (ambbuf
, ", ");
1248 strcat (ambbuf
, c
->name
);
1252 strcat (ambbuf
, "..");
1256 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1258 return 0; /* lint */
1263 /* We've got something. It may still not be what the caller
1264 wants (if this command *needs* a subcommand). */
1265 while (**line
== ' ' || **line
== '\t')
1268 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1269 undef_cmd_error (c
->prefixname
, *line
);
1271 /* Seems to be what he wants. Return it. */
1277 /* We are here presumably because an alias or command in *TEXT is
1278 deprecated and a warning message should be generated. This function
1279 decodes *TEXT and potentially generates a warning message as outlined
1282 Example for 'set endian big' which has a fictitious alias 'seb'.
1284 If alias wasn't used in *TEXT, and the command is deprecated:
1285 "warning: 'set endian big' is deprecated."
1287 If alias was used, and only the alias is deprecated:
1288 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1290 If alias was used and command is deprecated (regardless of whether the
1291 alias itself is deprecated:
1293 "warning: 'set endian big' (seb) is deprecated."
1295 After the message has been sent, clear the appropriate flags in the
1296 command and/or the alias so the user is no longer bothered.
1300 deprecated_cmd_warning (char **text
)
1302 struct cmd_list_element
*alias
= NULL
;
1303 struct cmd_list_element
*prefix_cmd
= NULL
;
1304 struct cmd_list_element
*cmd
= NULL
;
1305 struct cmd_list_element
*c
;
1308 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1309 /* return if text doesn't evaluate to a command */
1312 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1313 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1314 /* return if nothing is deprecated */
1317 printf_filtered ("Warning:");
1319 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1320 printf_filtered (" '%s', an alias for the", alias
->name
);
1322 printf_filtered (" command '");
1325 printf_filtered ("%s", prefix_cmd
->prefixname
);
1327 printf_filtered ("%s", cmd
->name
);
1329 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1330 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1332 printf_filtered ("' is deprecated.\n");
1335 /* if it is only the alias that is deprecated, we want to indicate the
1336 new alias, otherwise we'll indicate the new command */
1338 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1340 if (alias
->replacement
)
1341 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1343 printf_filtered ("No alternative known.\n\n");
1347 if (cmd
->replacement
)
1348 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1350 printf_filtered ("No alternative known.\n\n");
1353 /* We've warned you, now we'll keep quiet */
1355 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1357 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1362 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1363 Return 1 on success, 0 on failure.
1365 If LINE refers to an alias, *alias will point to that alias.
1367 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1368 command) set *prefix_cmd.
1370 Set *cmd to point to the command LINE indicates.
1372 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1373 exist, they are NULL when we return.
1377 lookup_cmd_composition (char *text
,
1378 struct cmd_list_element
**alias
,
1379 struct cmd_list_element
**prefix_cmd
,
1380 struct cmd_list_element
**cmd
)
1383 int len
, tmp
, nfound
;
1384 struct cmd_list_element
*cur_list
;
1385 struct cmd_list_element
*prev_cmd
;
1394 /* Go through as many command lists as we need to
1395 to find the command TEXT refers to. */
1399 while (*text
== ' ' || *text
== '\t')
1402 /* Treating underscores as part of command words is important
1403 so that "set args_foo()" doesn't get interpreted as
1404 "set args _foo()". */
1405 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1408 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1411 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1413 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1417 /* If nothing but whitespace, return. */
1423 /* text and p now bracket the first command word to lookup (and
1424 it's length is len). We copy this into a local temporary */
1426 command
= (char *) alloca (len
+ 1);
1427 for (tmp
= 0; tmp
< len
; tmp
++)
1432 command
[len
] = '\0';
1437 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1439 /* We didn't find the command in the entered case, so lower case it
1442 if (!*cmd
|| nfound
== 0)
1444 for (tmp
= 0; tmp
< len
; tmp
++)
1446 char x
= command
[tmp
];
1447 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1449 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1452 if (*cmd
== (struct cmd_list_element
*) -1)
1454 return 0; /* ambiguous */
1458 return 0; /* nothing found */
1461 if ((*cmd
)->cmd_pointer
)
1463 /* cmd was actually an alias, we note that an alias was used
1464 (by assigning *alais) and we set *cmd.
1467 *cmd
= (*cmd
)->cmd_pointer
;
1469 *prefix_cmd
= prev_cmd
;
1471 if ((*cmd
)->prefixlist
)
1472 cur_list
= *(*cmd
)->prefixlist
;
1480 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1482 /* Return a vector of char pointers which point to the different
1483 possible completions in LIST of TEXT.
1485 WORD points in the same buffer as TEXT, and completions should be
1486 returned relative to this position. For example, suppose TEXT is "foo"
1487 and we want to complete to "foobar". If WORD is "oo", return
1488 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1491 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1493 struct cmd_list_element
*ptr
;
1495 int sizeof_matchlist
;
1497 int textlen
= strlen (text
);
1499 sizeof_matchlist
= 10;
1500 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1503 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1504 if (!strncmp (ptr
->name
, text
, textlen
)
1505 && !ptr
->abbrev_flag
1507 || ptr
->prefixlist
))
1509 if (matches
== sizeof_matchlist
)
1511 sizeof_matchlist
*= 2;
1512 matchlist
= (char **) xrealloc ((char *) matchlist
,
1514 * sizeof (char *)));
1517 matchlist
[matches
] = (char *)
1518 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1520 strcpy (matchlist
[matches
], ptr
->name
);
1521 else if (word
> text
)
1523 /* Return some portion of ptr->name. */
1524 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1528 /* Return some of text plus ptr->name. */
1529 strncpy (matchlist
[matches
], word
, text
- word
);
1530 matchlist
[matches
][text
- word
] = '\0';
1531 strcat (matchlist
[matches
], ptr
->name
);
1543 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1544 * sizeof (char *)));
1545 matchlist
[matches
] = (char *) 0;
1551 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1553 /* Return a vector of char pointers which point to the different
1554 possible completions in CMD of TEXT.
1556 WORD points in the same buffer as TEXT, and completions should be
1557 returned relative to this position. For example, suppose TEXT is "foo"
1558 and we want to complete to "foobar". If WORD is "oo", return
1559 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1562 complete_on_enum (const char *enumlist
[],
1567 int sizeof_matchlist
;
1569 int textlen
= strlen (text
);
1573 sizeof_matchlist
= 10;
1574 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1577 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1578 if (strncmp (name
, text
, textlen
) == 0)
1580 if (matches
== sizeof_matchlist
)
1582 sizeof_matchlist
*= 2;
1583 matchlist
= (char **) xrealloc ((char *) matchlist
,
1585 * sizeof (char *)));
1588 matchlist
[matches
] = (char *)
1589 xmalloc (strlen (word
) + strlen (name
) + 1);
1591 strcpy (matchlist
[matches
], name
);
1592 else if (word
> text
)
1594 /* Return some portion of name. */
1595 strcpy (matchlist
[matches
], name
+ (word
- text
));
1599 /* Return some of text plus name. */
1600 strncpy (matchlist
[matches
], word
, text
- word
);
1601 matchlist
[matches
][text
- word
] = '\0';
1602 strcat (matchlist
[matches
], name
);
1614 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1615 * sizeof (char *)));
1616 matchlist
[matches
] = (char *) 0;
1623 /* check function pointer */
1625 cmd_func_p (struct cmd_list_element
*cmd
)
1627 return (cmd
->func
!= NULL
);
1631 /* call the command function */
1633 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1635 if (cmd_func_p (cmd
))
1636 (*cmd
->func
) (cmd
, args
, from_tty
);
1638 error (_("Invalid command"));