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
;
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 if (show_func
!= NULL
)
363 set_cmd_sfunc (show
, show_func
);
365 if (set_result
!= NULL
)
367 if (show_result
!= NULL
)
371 struct cmd_list_element
*
372 add_set_cmd (char *name
,
373 enum command_class
class,
377 struct cmd_list_element
**list
)
379 return add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
, doc
, list
);
382 /* Add element named NAME to command list LIST (the list for set
383 or some sublist thereof).
384 CLASS is as in add_cmd.
385 ENUMLIST is a list of strings which may follow NAME.
386 VAR is address of the variable which will contain the matching string
388 DOC is the documentation string. */
390 struct cmd_list_element
*
391 add_set_enum_cmd (char *name
,
392 enum command_class
class,
393 const char *enumlist
[],
396 struct cmd_list_element
**list
)
398 struct cmd_list_element
*c
399 = add_set_cmd (name
, class, var_enum
, var
, doc
, list
);
405 /* Add element named NAME to command list LIST (the list for set or
406 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
407 of strings which may follow NAME. VAR is address of the variable
408 which will contain the matching string (from ENUMLIST). */
411 add_setshow_enum_cmd (char *name
,
412 enum command_class
class,
413 const char *enumlist
[],
416 const char *show_doc
,
417 const char *help_doc
,
419 cmd_sfunc_ftype
*set_func
,
420 cmd_sfunc_ftype
*show_func
,
421 struct cmd_list_element
**set_list
,
422 struct cmd_list_element
**show_list
,
423 struct cmd_list_element
**set_result
,
424 struct cmd_list_element
**show_result
)
426 struct cmd_list_element
*c
;
427 add_setshow_cmd_full (name
, class, var_enum
, var
,
428 set_doc
, show_doc
, help_doc
, print
,
437 /* Add an auto-boolean command named NAME to both the set and show
438 command list lists. CLASS is as in add_cmd. VAR is address of the
439 variable which will contain the value. DOC is the documentation
440 string. FUNC is the corresponding callback. */
442 add_setshow_auto_boolean_cmd (char *name
,
443 enum command_class
class,
444 enum auto_boolean
*var
,
445 const char *set_doc
, const char *show_doc
,
446 const char *help_doc
, const char *print
,
447 cmd_sfunc_ftype
*set_func
,
448 cmd_sfunc_ftype
*show_func
,
449 struct cmd_list_element
**set_list
,
450 struct cmd_list_element
**show_list
)
452 static const char *auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
453 struct cmd_list_element
*c
;
454 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
455 set_doc
, show_doc
, help_doc
, print
,
459 c
->enums
= auto_boolean_enums
;
462 /* Add element named NAME to both the set and show command LISTs (the
463 list for set/show or some sublist thereof). CLASS is as in
464 add_cmd. VAR is address of the variable which will contain the
465 value. SET_DOC and SHOW_DOC are the documentation strings. */
467 add_setshow_boolean_cmd (char *name
, enum command_class
class, int *var
,
468 const char *set_doc
, const char *show_doc
,
469 const char *help_doc
, const char *print
,
470 cmd_sfunc_ftype
*set_func
,
471 cmd_sfunc_ftype
*show_func
,
472 struct cmd_list_element
**set_list
,
473 struct cmd_list_element
**show_list
)
475 static const char *boolean_enums
[] = { "on", "off", NULL
};
476 struct cmd_list_element
*c
;
477 add_setshow_cmd_full (name
, class, var_boolean
, var
,
478 set_doc
, show_doc
, help_doc
, print
,
482 c
->enums
= boolean_enums
;
485 /* Add element named NAME to both the set and show command LISTs (the
486 list for set/show or some sublist thereof). */
488 add_setshow_filename_cmd (char *name
, enum command_class
class,
490 const char *set_doc
, const char *show_doc
,
491 const char *help_doc
, const char *print
,
492 cmd_sfunc_ftype
*set_func
,
493 cmd_sfunc_ftype
*show_func
,
494 struct cmd_list_element
**set_list
,
495 struct cmd_list_element
**show_list
)
497 add_setshow_cmd_full (name
, class, var_filename
, var
,
498 set_doc
, show_doc
, help_doc
, print
,
504 /* Add element named NAME to both the set and show command LISTs (the
505 list for set/show or some sublist thereof). */
507 add_setshow_string_cmd (char *name
, enum command_class
class,
509 const char *set_doc
, const char *show_doc
,
510 const char *help_doc
, const char *print
,
511 cmd_sfunc_ftype
*set_func
,
512 cmd_sfunc_ftype
*show_func
,
513 struct cmd_list_element
**set_list
,
514 struct cmd_list_element
**show_list
)
516 add_setshow_cmd_full (name
, class, var_string
, var
,
517 set_doc
, show_doc
, help_doc
, print
,
523 /* Add element named NAME to both the set and show command LISTs (the
524 list for set/show or some sublist thereof). CLASS is as in
525 add_cmd. VAR is address of the variable which will contain the
526 value. SET_DOC and SHOW_DOC are the documentation strings. */
528 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
530 const char *set_doc
, const char *show_doc
,
531 const char *help_doc
, const char *print
,
532 cmd_sfunc_ftype
*set_func
,
533 cmd_sfunc_ftype
*show_func
,
534 struct cmd_list_element
**set_list
,
535 struct cmd_list_element
**show_list
)
537 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
538 set_doc
, show_doc
, help_doc
, print
,
544 /* Add element named NAME to both the set and show command LISTs (the
545 list for set/show or some sublist thereof). CLASS is as in
546 add_cmd. VAR is address of the variable which will contain the
547 value. SET_DOC and SHOW_DOC are the documentation strings. */
549 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
551 const char *set_doc
, const char *show_doc
,
552 const char *help_doc
, const char *print
,
553 cmd_sfunc_ftype
*set_func
,
554 cmd_sfunc_ftype
*show_func
,
555 struct cmd_list_element
**set_list
,
556 struct cmd_list_element
**show_list
)
558 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
559 set_doc
, show_doc
, help_doc
, print
,
565 /* Where SETCMD has already been added, add the corresponding show
566 command to LIST and return a pointer to the added command (not
567 necessarily the head of LIST). */
568 /* NOTE: cagney/2002-03-17: The original version of
569 deprecated_add_show_from_set used memcpy() to clone `set' into
570 `show'. This meant that in addition to all the needed fields (var,
571 name, et.al.) some unnecessary fields were copied (namely the
572 callback function). The function explictly copies relevant fields.
573 For a `set' and `show' command to share the same callback, the
574 caller must set both explicitly. */
575 struct cmd_list_element
*
576 deprecated_add_show_from_set (struct cmd_list_element
*setcmd
,
577 struct cmd_list_element
**list
)
580 const static char setstring
[] = "Set ";
582 /* Create a doc string by replacing "Set " at the start of the
583 `set'' command's doco with "Show ". */
584 gdb_assert (strncmp (setcmd
->doc
, setstring
, sizeof (setstring
) - 1) == 0);
585 doc
= concat ("Show ", setcmd
->doc
+ sizeof (setstring
) - 1, NULL
);
587 /* Insert the basic command. */
588 return add_set_or_show_cmd (setcmd
->name
, show_cmd
, setcmd
->class,
589 setcmd
->var_type
, setcmd
->var
, doc
, list
);
592 /* Remove the command named NAME from the command list. */
595 delete_cmd (char *name
, struct cmd_list_element
**list
)
597 struct cmd_list_element
*c
;
598 struct cmd_list_element
*p
;
600 while (*list
&& strcmp ((*list
)->name
, name
) == 0)
602 if ((*list
)->hookee_pre
)
603 (*list
)->hookee_pre
->hook_pre
= 0; /* Hook slips out of its mouth */
604 if ((*list
)->hookee_post
)
605 (*list
)->hookee_post
->hook_post
= 0; /* Hook slips out of its bottom */
612 for (c
= *list
; c
->next
;)
614 if (strcmp (c
->next
->name
, name
) == 0)
616 if (c
->next
->hookee_pre
)
617 c
->next
->hookee_pre
->hook_pre
= 0; /* hooked cmd gets away. */
618 if (c
->next
->hookee_post
)
619 c
->next
->hookee_post
->hook_post
= 0; /* remove post hook */
620 /* :( no fishing metaphore */
630 /* Shorthands to the commands above. */
632 /* Add an element to the list of info subcommands. */
634 struct cmd_list_element
*
635 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
637 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
640 /* Add an alias to the list of info subcommands. */
642 struct cmd_list_element
*
643 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
645 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
648 /* Add an element to the list of commands. */
650 struct cmd_list_element
*
651 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
654 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
657 /* Add an alias or abbreviation command to the list of commands. */
659 struct cmd_list_element
*
660 add_com_alias (char *name
, char *oldname
, enum command_class
class,
663 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
666 /* Recursively walk the commandlist structures, and print out the
667 documentation of commands that match our regex in either their
668 name, or their documentation.
671 apropos_cmd (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
672 struct re_pattern_buffer
*regex
, char *prefix
)
674 struct cmd_list_element
*c
;
675 int returnvalue
=1; /*Needed to avoid double printing*/
676 /* Walk through the commands */
677 for (c
=commandlist
;c
;c
=c
->next
)
681 /* Try to match against the name*/
682 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
683 if (returnvalue
>= 0)
685 /* Stolen from help_cmd_list. We don't directly use
686 * help_cmd_list because it doesn't let us print out
689 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
690 print_doc_line (stream
, c
->doc
);
691 fputs_filtered ("\n", stream
);
692 returnvalue
=0; /*Set this so we don't print it again.*/
695 if (c
->doc
!= NULL
&& returnvalue
!= 0)
697 /* Try to match against documentation */
698 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
700 /* Stolen from help_cmd_list. We don't directly use
701 * help_cmd_list because it doesn't let us print out
704 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
705 print_doc_line (stream
, c
->doc
);
706 fputs_filtered ("\n", stream
);
709 /* Check if this command has subcommands */
710 if (c
->prefixlist
!= NULL
)
712 /* Recursively call ourselves on the subcommand list,
713 passing the right prefix in.
715 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
720 /* This command really has to deal with two things:
721 * 1) I want documentation on *this string* (usually called by
722 * "help commandname").
723 * 2) I want documentation on *this list* (usually called by
724 * giving a command that requires subcommands. Also called by saying
727 * I am going to split this into two seperate comamnds, help_cmd and
732 help_cmd (char *command
, struct ui_file
*stream
)
734 struct cmd_list_element
*c
;
735 extern struct cmd_list_element
*cmdlist
;
739 help_list (cmdlist
, "", all_classes
, stream
);
743 if (strcmp (command
, "all") == 0)
749 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
754 /* There are three cases here.
755 If c->prefixlist is nonzero, we have a prefix command.
756 Print its documentation, then list its subcommands.
758 If c->func is non NULL, we really have a command. Print its
759 documentation and return.
761 If c->func is NULL, we have a class name. Print its
762 documentation (as if it were a command) and then set class to the
763 number of this class so that the commands in the class will be
766 fputs_filtered (c
->doc
, stream
);
767 fputs_filtered ("\n", stream
);
769 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
771 fprintf_filtered (stream
, "\n");
773 /* If this is a prefix command, print it's subcommands */
775 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
777 /* If this is a class name, print all of the commands in the class */
779 help_list (cmdlist
, "", c
->class, stream
);
781 if (c
->hook_pre
|| c
->hook_post
)
782 fprintf_filtered (stream
,
783 "\nThis command has a hook (or hooks) defined:\n");
786 fprintf_filtered (stream
,
787 "\tThis command is run after : %s (pre hook)\n",
790 fprintf_filtered (stream
,
791 "\tThis command is run before : %s (post hook)\n",
796 * Get a specific kind of help on a command list.
799 * CMDTYPE is the prefix to use in the title string.
800 * CLASS is the class with which to list the nodes of this list (see
801 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
802 * everything, ALL_CLASSES for just classes, and non-negative for only things
803 * in a specific class.
804 * and STREAM is the output stream on which to print things.
805 * If you call this routine with a class >= 0, it recurses.
808 help_list (struct cmd_list_element
*list
, char *cmdtype
,
809 enum command_class
class, struct ui_file
*stream
)
812 char *cmdtype1
, *cmdtype2
;
814 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
815 len
= strlen (cmdtype
);
816 cmdtype1
= (char *) alloca (len
+ 1);
818 cmdtype2
= (char *) alloca (len
+ 4);
823 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
825 strncpy (cmdtype2
, cmdtype
, len
- 1);
826 strcpy (cmdtype2
+ len
- 1, " sub");
829 if (class == all_classes
)
830 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
832 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
834 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
836 if (class == all_classes
)
838 fprintf_filtered (stream
, "\n\
839 Type \"help%s\" followed by a class name for a list of commands in ",
842 fprintf_filtered (stream
, "that class.");
845 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
848 fputs_filtered ("for ", stream
);
850 fputs_filtered ("full ", stream
);
852 fputs_filtered ("documentation.\n", stream
);
853 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
858 help_all (struct ui_file
*stream
)
860 struct cmd_list_element
*c
;
861 extern struct cmd_list_element
*cmdlist
;
863 for (c
= cmdlist
; c
; c
= c
->next
)
867 /* If this is a prefix command, print it's subcommands */
869 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 0, stream
);
871 /* If this is a class name, print all of the commands in the class */
872 else if (c
->func
== NULL
)
873 help_cmd_list (cmdlist
, c
->class, "", 0, stream
);
877 /* Print only the first line of STR on STREAM. */
879 print_doc_line (struct ui_file
*stream
, char *str
)
881 static char *line_buffer
= 0;
882 static int line_size
;
888 line_buffer
= (char *) xmalloc (line_size
);
892 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
894 if (p
- str
> line_size
- 1)
896 line_size
= p
- str
+ 1;
898 line_buffer
= (char *) xmalloc (line_size
);
900 strncpy (line_buffer
, str
, p
- str
);
901 line_buffer
[p
- str
] = '\0';
902 if (islower (line_buffer
[0]))
903 line_buffer
[0] = toupper (line_buffer
[0]);
904 ui_out_text (uiout
, line_buffer
);
908 * Implement a help command on command list LIST.
909 * RECURSE should be non-zero if this should be done recursively on
910 * all sublists of LIST.
911 * PREFIX is the prefix to print before each command name.
912 * STREAM is the stream upon which the output should be written.
914 * A non-negative class number to list only commands in that
916 * ALL_COMMANDS to list all commands in list.
917 * ALL_CLASSES to list all classes in list.
919 * Note that RECURSE will be active on *all* sublists, not just the
920 * ones selected by the criteria above (ie. the selection mechanism
921 * is at the low level, not the high-level).
924 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
925 char *prefix
, int recurse
, struct ui_file
*stream
)
927 struct cmd_list_element
*c
;
929 for (c
= list
; c
; c
= c
->next
)
931 if (c
->abbrev_flag
== 0 &&
932 (class == all_commands
933 || (class == all_classes
&& c
->func
== NULL
)
934 || (class == c
->class && c
->func
!= NULL
)))
936 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
937 print_doc_line (stream
, c
->doc
);
938 fputs_filtered ("\n", stream
);
941 && c
->prefixlist
!= 0
942 && c
->abbrev_flag
== 0)
943 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
, 1, stream
);
948 /* Search the input clist for 'command'. Return the command if
949 found (or NULL if not), and return the number of commands
952 static struct cmd_list_element
*
953 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
954 int ignore_help_classes
, int *nfound
)
956 struct cmd_list_element
*found
, *c
;
958 found
= (struct cmd_list_element
*) NULL
;
960 for (c
= clist
; c
; c
= c
->next
)
961 if (!strncmp (command
, c
->name
, len
)
962 && (!ignore_help_classes
|| c
->func
))
966 if (c
->name
[len
] == '\0')
975 /* This routine takes a line of TEXT and a CLIST in which to start the
976 lookup. When it returns it will have incremented the text pointer past
977 the section of text it matched, set *RESULT_LIST to point to the list in
978 which the last word was matched, and will return a pointer to the cmd
979 list element which the text matches. It will return NULL if no match at
980 all was possible. It will return -1 (cast appropriately, ick) if ambigous
981 matches are possible; in this case *RESULT_LIST will be set to point to
982 the list in which there are ambiguous choices (and *TEXT will be set to
983 the ambiguous text string).
985 If the located command was an abbreviation, this routine returns the base
986 command of the abbreviation.
988 It does no error reporting whatsoever; control will always return
989 to the superior routine.
991 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
992 at the prefix_command (ie. the best match) *or* (special case) will be NULL
993 if no prefix command was ever found. For example, in the case of "info a",
994 "info" matches without ambiguity, but "a" could be "args" or "address", so
995 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
996 RESULT_LIST should not be interpeted as a pointer to the beginning of a
997 list; it simply points to a specific command. In the case of an ambiguous
998 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
999 "info t" can be "info types" or "info target"; upon return *TEXT has been
1000 advanced past "info ").
1002 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1003 affect the operation).
1005 This routine does *not* modify the text pointed to by TEXT.
1007 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1008 are actually help classes rather than commands (i.e. the function field of
1009 the struct cmd_list_element is NULL). */
1011 struct cmd_list_element
*
1012 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
1013 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1016 int len
, tmp
, nfound
;
1017 struct cmd_list_element
*found
, *c
;
1020 while (**text
== ' ' || **text
== '\t')
1023 /* Treating underscores as part of command words is important
1024 so that "set args_foo()" doesn't get interpreted as
1025 "set args _foo()". */
1026 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1029 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1032 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1034 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1038 /* If nothing but whitespace, return 0. */
1044 /* *text and p now bracket the first command word to lookup (and
1045 it's length is len). We copy this into a local temporary */
1048 command
= (char *) alloca (len
+ 1);
1049 for (tmp
= 0; tmp
< len
; tmp
++)
1051 char x
= (*text
)[tmp
];
1054 command
[len
] = '\0';
1059 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1062 ** We didn't find the command in the entered case, so lower case it
1063 ** and search again.
1065 if (!found
|| nfound
== 0)
1067 for (tmp
= 0; tmp
< len
; tmp
++)
1069 char x
= command
[tmp
];
1070 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1072 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1075 /* If nothing matches, we have a simple failure. */
1081 if (result_list
!= NULL
)
1082 /* Will be modified in calling routine
1083 if we know what the prefix command is. */
1085 return (struct cmd_list_element
*) -1; /* Ambiguous. */
1088 /* We've matched something on this list. Move text pointer forward. */
1092 if (found
->cmd_pointer
)
1094 /* We drop the alias (abbreviation) in favor of the command it is
1095 pointing to. If the alias is deprecated, though, we need to
1096 warn the user about it before we drop it. Note that while we
1097 are warning about the alias, we may also warn about the command
1098 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1101 if (found
->flags
& DEPRECATED_WARN_USER
)
1102 deprecated_cmd_warning (&line
);
1103 found
= found
->cmd_pointer
;
1105 /* If we found a prefix command, keep looking. */
1107 if (found
->prefixlist
)
1109 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1110 ignore_help_classes
);
1113 /* Didn't find anything; this is as far as we got. */
1114 if (result_list
!= NULL
)
1115 *result_list
= clist
;
1118 else if (c
== (struct cmd_list_element
*) -1)
1120 /* We've gotten this far properly, but the next step
1121 is ambiguous. We need to set the result list to the best
1122 we've found (if an inferior hasn't already set it). */
1123 if (result_list
!= NULL
)
1125 /* This used to say *result_list = *found->prefixlist
1126 If that was correct, need to modify the documentation
1127 at the top of this function to clarify what is supposed
1129 *result_list
= found
;
1140 if (result_list
!= NULL
)
1141 *result_list
= clist
;
1146 /* All this hair to move the space to the front of cmdtype */
1149 undef_cmd_error (char *cmdtype
, char *q
)
1151 error ("Undefined %scommand: \"%s\". Try \"help%s%.*s\".",
1154 *cmdtype
? " " : "",
1155 (int) strlen (cmdtype
) - 1,
1159 /* Look up the contents of *LINE as a command in the command list LIST.
1160 LIST is a chain of struct cmd_list_element's.
1161 If it is found, return the struct cmd_list_element for that command
1162 and update *LINE to point after the command name, at the first argument.
1163 If not found, call error if ALLOW_UNKNOWN is zero
1164 otherwise (or if error returns) return zero.
1165 Call error if specified command is ambiguous,
1166 unless ALLOW_UNKNOWN is negative.
1167 CMDTYPE precedes the word "command" in the error message.
1169 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1170 elements which are actually help classes rather than commands (i.e.
1171 the function field of the struct cmd_list_element is 0). */
1173 struct cmd_list_element
*
1174 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1175 int allow_unknown
, int ignore_help_classes
)
1177 struct cmd_list_element
*last_list
= 0;
1178 struct cmd_list_element
*c
=
1179 lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1181 /* Note: Do not remove trailing whitespace here because this
1182 would be wrong for complete_command. Jim Kingdon */
1189 error ("Lack of needed %scommand", cmdtype
);
1192 char *p
= *line
, *q
;
1194 while (isalnum (*p
) || *p
== '-')
1197 q
= (char *) alloca (p
- *line
+ 1);
1198 strncpy (q
, *line
, p
- *line
);
1199 q
[p
- *line
] = '\0';
1200 undef_cmd_error (cmdtype
, q
);
1206 else if (c
== (struct cmd_list_element
*) -1)
1208 /* Ambigous. Local values should be off prefixlist or called
1210 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1212 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1213 struct cmd_list_element
*local_list
=
1214 (last_list
? *(last_list
->prefixlist
) : list
);
1216 if (local_allow_unknown
< 0)
1219 return last_list
; /* Found something. */
1221 return 0; /* Found nothing. */
1225 /* Report as error. */
1230 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1231 && (*line
)[amb_len
] != '\t');
1236 for (c
= local_list
; c
; c
= c
->next
)
1237 if (!strncmp (*line
, c
->name
, amb_len
))
1239 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1241 if (strlen (ambbuf
))
1242 strcat (ambbuf
, ", ");
1243 strcat (ambbuf
, c
->name
);
1247 strcat (ambbuf
, "..");
1251 error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype
,
1253 return 0; /* lint */
1258 /* We've got something. It may still not be what the caller
1259 wants (if this command *needs* a subcommand). */
1260 while (**line
== ' ' || **line
== '\t')
1263 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1264 undef_cmd_error (c
->prefixname
, *line
);
1266 /* Seems to be what he wants. Return it. */
1272 /* We are here presumably because an alias or command in *TEXT is
1273 deprecated and a warning message should be generated. This function
1274 decodes *TEXT and potentially generates a warning message as outlined
1277 Example for 'set endian big' which has a fictitious alias 'seb'.
1279 If alias wasn't used in *TEXT, and the command is deprecated:
1280 "warning: 'set endian big' is deprecated."
1282 If alias was used, and only the alias is deprecated:
1283 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1285 If alias was used and command is deprecated (regardless of whether the
1286 alias itself is deprecated:
1288 "warning: 'set endian big' (seb) is deprecated."
1290 After the message has been sent, clear the appropriate flags in the
1291 command and/or the alias so the user is no longer bothered.
1295 deprecated_cmd_warning (char **text
)
1297 struct cmd_list_element
*alias
= NULL
;
1298 struct cmd_list_element
*prefix_cmd
= NULL
;
1299 struct cmd_list_element
*cmd
= NULL
;
1300 struct cmd_list_element
*c
;
1303 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1304 /* return if text doesn't evaluate to a command */
1307 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1308 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1309 /* return if nothing is deprecated */
1312 printf_filtered ("Warning:");
1314 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1315 printf_filtered (" '%s', an alias for the", alias
->name
);
1317 printf_filtered (" command '");
1320 printf_filtered ("%s", prefix_cmd
->prefixname
);
1322 printf_filtered ("%s", cmd
->name
);
1324 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1325 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1327 printf_filtered ("' is deprecated.\n");
1330 /* if it is only the alias that is deprecated, we want to indicate the
1331 new alias, otherwise we'll indicate the new command */
1333 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1335 if (alias
->replacement
)
1336 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1338 printf_filtered ("No alternative known.\n\n");
1342 if (cmd
->replacement
)
1343 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1345 printf_filtered ("No alternative known.\n\n");
1348 /* We've warned you, now we'll keep quiet */
1350 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1352 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1357 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1358 Return 1 on success, 0 on failure.
1360 If LINE refers to an alias, *alias will point to that alias.
1362 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1363 command) set *prefix_cmd.
1365 Set *cmd to point to the command LINE indicates.
1367 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1368 exist, they are NULL when we return.
1372 lookup_cmd_composition (char *text
,
1373 struct cmd_list_element
**alias
,
1374 struct cmd_list_element
**prefix_cmd
,
1375 struct cmd_list_element
**cmd
)
1378 int len
, tmp
, nfound
;
1379 struct cmd_list_element
*cur_list
;
1380 struct cmd_list_element
*prev_cmd
;
1389 /* Go through as many command lists as we need to
1390 to find the command TEXT refers to. */
1394 while (*text
== ' ' || *text
== '\t')
1397 /* Treating underscores as part of command words is important
1398 so that "set args_foo()" doesn't get interpreted as
1399 "set args _foo()". */
1400 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1403 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1406 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1408 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1412 /* If nothing but whitespace, return. */
1418 /* text and p now bracket the first command word to lookup (and
1419 it's length is len). We copy this into a local temporary */
1421 command
= (char *) alloca (len
+ 1);
1422 for (tmp
= 0; tmp
< len
; tmp
++)
1427 command
[len
] = '\0';
1432 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1434 /* We didn't find the command in the entered case, so lower case it
1437 if (!*cmd
|| nfound
== 0)
1439 for (tmp
= 0; tmp
< len
; tmp
++)
1441 char x
= command
[tmp
];
1442 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1444 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1447 if (*cmd
== (struct cmd_list_element
*) -1)
1449 return 0; /* ambiguous */
1453 return 0; /* nothing found */
1456 if ((*cmd
)->cmd_pointer
)
1458 /* cmd was actually an alias, we note that an alias was used
1459 (by assigning *alais) and we set *cmd.
1462 *cmd
= (*cmd
)->cmd_pointer
;
1464 *prefix_cmd
= prev_cmd
;
1466 if ((*cmd
)->prefixlist
)
1467 cur_list
= *(*cmd
)->prefixlist
;
1475 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1477 /* Return a vector of char pointers which point to the different
1478 possible completions in LIST of TEXT.
1480 WORD points in the same buffer as TEXT, and completions should be
1481 returned relative to this position. For example, suppose TEXT is "foo"
1482 and we want to complete to "foobar". If WORD is "oo", return
1483 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1486 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1488 struct cmd_list_element
*ptr
;
1490 int sizeof_matchlist
;
1492 int textlen
= strlen (text
);
1494 sizeof_matchlist
= 10;
1495 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1498 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1499 if (!strncmp (ptr
->name
, text
, textlen
)
1500 && !ptr
->abbrev_flag
1502 || ptr
->prefixlist
))
1504 if (matches
== sizeof_matchlist
)
1506 sizeof_matchlist
*= 2;
1507 matchlist
= (char **) xrealloc ((char *) matchlist
,
1509 * sizeof (char *)));
1512 matchlist
[matches
] = (char *)
1513 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1515 strcpy (matchlist
[matches
], ptr
->name
);
1516 else if (word
> text
)
1518 /* Return some portion of ptr->name. */
1519 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1523 /* Return some of text plus ptr->name. */
1524 strncpy (matchlist
[matches
], word
, text
- word
);
1525 matchlist
[matches
][text
- word
] = '\0';
1526 strcat (matchlist
[matches
], ptr
->name
);
1538 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1539 * sizeof (char *)));
1540 matchlist
[matches
] = (char *) 0;
1546 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1548 /* Return a vector of char pointers which point to the different
1549 possible completions in CMD of TEXT.
1551 WORD points in the same buffer as TEXT, and completions should be
1552 returned relative to this position. For example, suppose TEXT is "foo"
1553 and we want to complete to "foobar". If WORD is "oo", return
1554 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1557 complete_on_enum (const char *enumlist
[],
1562 int sizeof_matchlist
;
1564 int textlen
= strlen (text
);
1568 sizeof_matchlist
= 10;
1569 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1572 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1573 if (strncmp (name
, text
, textlen
) == 0)
1575 if (matches
== sizeof_matchlist
)
1577 sizeof_matchlist
*= 2;
1578 matchlist
= (char **) xrealloc ((char *) matchlist
,
1580 * sizeof (char *)));
1583 matchlist
[matches
] = (char *)
1584 xmalloc (strlen (word
) + strlen (name
) + 1);
1586 strcpy (matchlist
[matches
], name
);
1587 else if (word
> text
)
1589 /* Return some portion of name. */
1590 strcpy (matchlist
[matches
], name
+ (word
- text
));
1594 /* Return some of text plus name. */
1595 strncpy (matchlist
[matches
], word
, text
- word
);
1596 matchlist
[matches
][text
- word
] = '\0';
1597 strcat (matchlist
[matches
], name
);
1609 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1610 * sizeof (char *)));
1611 matchlist
[matches
] = (char *) 0;
1618 /* check function pointer */
1620 cmd_func_p (struct cmd_list_element
*cmd
)
1622 return (cmd
->func
!= NULL
);
1626 /* call the command function */
1628 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1630 if (cmd_func_p (cmd
))
1631 (*cmd
->func
) (cmd
, args
, from_tty
);
1633 error ("Invalid command");