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
,
334 fprint_setshow_ftype
*fprint_setshow
,
335 cmd_sfunc_ftype
*set_func
,
336 show_value_ftype
*show_func
,
337 struct cmd_list_element
**set_list
,
338 struct cmd_list_element
**show_list
,
339 struct cmd_list_element
**set_result
,
340 struct cmd_list_element
**show_result
)
342 struct cmd_list_element
*set
;
343 struct cmd_list_element
*show
;
347 if (help_doc
!= NULL
)
349 full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
350 full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
354 full_set_doc
= xstrdup (set_doc
);
355 full_show_doc
= xstrdup (show_doc
);
357 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
358 full_set_doc
, set_list
);
359 if (set_func
!= NULL
)
360 set_cmd_sfunc (set
, set_func
);
361 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
362 full_show_doc
, show_list
);
363 show
->show_value_func
= 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
,
418 fprint_setshow_ftype
*fprint_setshow
,
419 cmd_sfunc_ftype
*set_func
,
420 show_value_ftype
*show_func
,
421 struct cmd_list_element
**set_list
,
422 struct cmd_list_element
**show_list
)
424 struct cmd_list_element
*c
;
425 add_setshow_cmd_full (name
, class, var_enum
, var
,
426 set_doc
, show_doc
, help_doc
,
434 /* Add an auto-boolean command named NAME to both the set and show
435 command list lists. CLASS is as in add_cmd. VAR is address of the
436 variable which will contain the value. DOC is the documentation
437 string. FUNC is the corresponding callback. */
439 add_setshow_auto_boolean_cmd (char *name
,
440 enum command_class
class,
441 enum auto_boolean
*var
,
442 const char *set_doc
, const char *show_doc
,
443 const char *help_doc
,
444 fprint_setshow_ftype
*fprint_setshow
,
445 cmd_sfunc_ftype
*set_func
,
446 show_value_ftype
*show_func
,
447 struct cmd_list_element
**set_list
,
448 struct cmd_list_element
**show_list
)
450 static const char *auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
451 struct cmd_list_element
*c
;
452 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
453 set_doc
, show_doc
, help_doc
, fprint_setshow
,
457 c
->enums
= auto_boolean_enums
;
460 /* Add element named NAME to both the set and show command LISTs (the
461 list for set/show or some sublist thereof). CLASS is as in
462 add_cmd. VAR is address of the variable which will contain the
463 value. SET_DOC and SHOW_DOC are the documentation strings. */
465 add_setshow_boolean_cmd (char *name
, enum command_class
class, int *var
,
466 const char *set_doc
, const char *show_doc
,
467 const char *help_doc
,
468 fprint_setshow_ftype
*fprint_setshow
,
469 cmd_sfunc_ftype
*set_func
,
470 show_value_ftype
*show_func
,
471 struct cmd_list_element
**set_list
,
472 struct cmd_list_element
**show_list
)
474 static const char *boolean_enums
[] = { "on", "off", NULL
};
475 struct cmd_list_element
*c
;
476 add_setshow_cmd_full (name
, class, var_boolean
, var
,
477 set_doc
, show_doc
, help_doc
, fprint_setshow
,
481 c
->enums
= boolean_enums
;
484 /* Add element named NAME to both the set and show command LISTs (the
485 list for set/show or some sublist thereof). */
487 add_setshow_filename_cmd (char *name
, enum command_class
class,
489 const char *set_doc
, const char *show_doc
,
490 const char *help_doc
,
491 fprint_setshow_ftype
*fprint_setshow
,
492 cmd_sfunc_ftype
*set_func
,
493 show_value_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
, fprint_setshow
,
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
,
511 fprint_setshow_ftype
*fprint_setshow
,
512 cmd_sfunc_ftype
*set_func
,
513 show_value_ftype
*show_func
,
514 struct cmd_list_element
**set_list
,
515 struct cmd_list_element
**show_list
)
517 add_setshow_cmd_full (name
, class, var_string
, var
,
518 set_doc
, show_doc
, help_doc
, fprint_setshow
,
524 /* Add element named NAME to both the set and show command LISTs (the
525 list for set/show or some sublist thereof). CLASS is as in
526 add_cmd. VAR is address of the variable which will contain the
527 value. SET_DOC and SHOW_DOC are the documentation strings. */
529 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
531 const char *set_doc
, const char *show_doc
,
532 const char *help_doc
,
533 fprint_setshow_ftype
*fprint_setshow
,
534 cmd_sfunc_ftype
*set_func
,
535 show_value_ftype
*show_func
,
536 struct cmd_list_element
**set_list
,
537 struct cmd_list_element
**show_list
)
539 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
540 set_doc
, show_doc
, help_doc
, fprint_setshow
,
546 /* Add element named NAME to both the set and show command LISTs (the
547 list for set/show or some sublist thereof). CLASS is as in
548 add_cmd. VAR is address of the variable which will contain the
549 value. SET_DOC and SHOW_DOC are the documentation strings. */
551 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
553 const char *set_doc
, const char *show_doc
,
554 const char *help_doc
,
555 fprint_setshow_ftype
*fprint_setshow
,
556 cmd_sfunc_ftype
*set_func
,
557 show_value_ftype
*show_func
,
558 struct cmd_list_element
**set_list
,
559 struct cmd_list_element
**show_list
)
561 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
562 set_doc
, show_doc
, help_doc
, fprint_setshow
,
568 /* Where SETCMD has already been added, add the corresponding show
569 command to LIST and return a pointer to the added command (not
570 necessarily the head of LIST). */
571 /* NOTE: cagney/2002-03-17: The original version of
572 deprecated_add_show_from_set used memcpy() to clone `set' into
573 `show'. This meant that in addition to all the needed fields (var,
574 name, et.al.) some unnecessary fields were copied (namely the
575 callback function). The function explictly copies relevant fields.
576 For a `set' and `show' command to share the same callback, the
577 caller must set both explicitly. */
578 struct cmd_list_element
*
579 deprecated_add_show_from_set (struct cmd_list_element
*setcmd
,
580 struct cmd_list_element
**list
)
583 const static char setstring
[] = "Set ";
585 /* Create a doc string by replacing "Set " at the start of the
586 `set'' command's doco with "Show ". */
587 gdb_assert (strncmp (setcmd
->doc
, setstring
, sizeof (setstring
) - 1) == 0);
588 doc
= concat ("Show ", setcmd
->doc
+ sizeof (setstring
) - 1, NULL
);
590 /* Insert the basic command. */
591 return add_set_or_show_cmd (setcmd
->name
, show_cmd
, setcmd
->class,
592 setcmd
->var_type
, setcmd
->var
, doc
, list
);
595 /* Remove the command named NAME from the command list. */
598 delete_cmd (char *name
, struct cmd_list_element
**list
)
600 struct cmd_list_element
*c
;
601 struct cmd_list_element
*p
;
603 while (*list
&& strcmp ((*list
)->name
, name
) == 0)
605 if ((*list
)->hookee_pre
)
606 (*list
)->hookee_pre
->hook_pre
= 0; /* Hook slips out of its mouth */
607 if ((*list
)->hookee_post
)
608 (*list
)->hookee_post
->hook_post
= 0; /* Hook slips out of its bottom */
615 for (c
= *list
; c
->next
;)
617 if (strcmp (c
->next
->name
, name
) == 0)
619 if (c
->next
->hookee_pre
)
620 c
->next
->hookee_pre
->hook_pre
= 0; /* hooked cmd gets away. */
621 if (c
->next
->hookee_post
)
622 c
->next
->hookee_post
->hook_post
= 0; /* remove post hook */
623 /* :( no fishing metaphore */
633 /* Shorthands to the commands above. */
635 /* Add an element to the list of info subcommands. */
637 struct cmd_list_element
*
638 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
640 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
643 /* Add an alias to the list of info subcommands. */
645 struct cmd_list_element
*
646 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
648 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
651 /* Add an element to the list of commands. */
653 struct cmd_list_element
*
654 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
657 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
660 /* Add an alias or abbreviation command to the list of commands. */
662 struct cmd_list_element
*
663 add_com_alias (char *name
, char *oldname
, enum command_class
class,
666 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
669 /* Recursively walk the commandlist structures, and print out the
670 documentation of commands that match our regex in either their
671 name, or their documentation.
674 apropos_cmd (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
675 struct re_pattern_buffer
*regex
, char *prefix
)
677 struct cmd_list_element
*c
;
678 int returnvalue
=1; /*Needed to avoid double printing*/
679 /* Walk through the commands */
680 for (c
=commandlist
;c
;c
=c
->next
)
684 /* Try to match against the name*/
685 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
686 if (returnvalue
>= 0)
688 /* Stolen from help_cmd_list. We don't directly use
689 * help_cmd_list because it doesn't let us print out
692 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
693 print_doc_line (stream
, c
->doc
);
694 fputs_filtered ("\n", stream
);
695 returnvalue
=0; /*Set this so we don't print it again.*/
698 if (c
->doc
!= NULL
&& returnvalue
!= 0)
700 /* Try to match against documentation */
701 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
703 /* Stolen from help_cmd_list. We don't directly use
704 * help_cmd_list because it doesn't let us print out
707 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
708 print_doc_line (stream
, c
->doc
);
709 fputs_filtered ("\n", stream
);
712 /* Check if this command has subcommands */
713 if (c
->prefixlist
!= NULL
)
715 /* Recursively call ourselves on the subcommand list,
716 passing the right prefix in.
718 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
723 /* This command really has to deal with two things:
724 * 1) I want documentation on *this string* (usually called by
725 * "help commandname").
726 * 2) I want documentation on *this list* (usually called by
727 * giving a command that requires subcommands. Also called by saying
730 * I am going to split this into two seperate comamnds, help_cmd and
735 help_cmd (char *command
, struct ui_file
*stream
)
737 struct cmd_list_element
*c
;
738 extern struct cmd_list_element
*cmdlist
;
742 help_list (cmdlist
, "", all_classes
, stream
);
746 if (strcmp (command
, "all") == 0)
752 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
757 /* There are three cases here.
758 If c->prefixlist is nonzero, we have a prefix command.
759 Print its documentation, then list its subcommands.
761 If c->func is non NULL, we really have a command. Print its
762 documentation and return.
764 If c->func is NULL, we have a class name. Print its
765 documentation (as if it were a command) and then set class to the
766 number of this class so that the commands in the class will be
769 fputs_filtered (c
->doc
, stream
);
770 fputs_filtered ("\n", stream
);
772 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
774 fprintf_filtered (stream
, "\n");
776 /* If this is a prefix command, print it's subcommands */
778 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
780 /* If this is a class name, print all of the commands in the class */
782 help_list (cmdlist
, "", c
->class, stream
);
784 if (c
->hook_pre
|| c
->hook_post
)
785 fprintf_filtered (stream
,
786 "\nThis command has a hook (or hooks) defined:\n");
789 fprintf_filtered (stream
,
790 "\tThis command is run after : %s (pre hook)\n",
793 fprintf_filtered (stream
,
794 "\tThis command is run before : %s (post hook)\n",
799 * Get a specific kind of help on a command list.
802 * CMDTYPE is the prefix to use in the title string.
803 * CLASS is the class with which to list the nodes of this list (see
804 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
805 * everything, ALL_CLASSES for just classes, and non-negative for only things
806 * in a specific class.
807 * and STREAM is the output stream on which to print things.
808 * If you call this routine with a class >= 0, it recurses.
811 help_list (struct cmd_list_element
*list
, char *cmdtype
,
812 enum command_class
class, struct ui_file
*stream
)
815 char *cmdtype1
, *cmdtype2
;
817 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
818 len
= strlen (cmdtype
);
819 cmdtype1
= (char *) alloca (len
+ 1);
821 cmdtype2
= (char *) alloca (len
+ 4);
826 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
828 strncpy (cmdtype2
, cmdtype
, len
- 1);
829 strcpy (cmdtype2
+ len
- 1, " sub");
832 if (class == all_classes
)
833 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
835 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
837 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
839 if (class == all_classes
)
841 fprintf_filtered (stream
, "\n\
842 Type \"help%s\" followed by a class name for a list of commands in ",
845 fprintf_filtered (stream
, "that class.");
848 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
851 fputs_filtered ("for ", stream
);
853 fputs_filtered ("full ", stream
);
855 fputs_filtered ("documentation.\n", stream
);
856 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
861 help_all (struct ui_file
*stream
)
863 struct cmd_list_element
*c
;
864 extern struct cmd_list_element
*cmdlist
;
866 for (c
= cmdlist
; c
; c
= c
->next
)
870 /* If this is a prefix command, print it's subcommands */
872 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 0, stream
);
874 /* If this is a class name, print all of the commands in the class */
875 else if (c
->func
== NULL
)
876 help_cmd_list (cmdlist
, c
->class, "", 0, stream
);
880 /* Print only the first line of STR on STREAM. */
882 print_doc_line (struct ui_file
*stream
, char *str
)
884 static char *line_buffer
= 0;
885 static int line_size
;
891 line_buffer
= (char *) xmalloc (line_size
);
895 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
897 if (p
- str
> line_size
- 1)
899 line_size
= p
- str
+ 1;
901 line_buffer
= (char *) xmalloc (line_size
);
903 strncpy (line_buffer
, str
, p
- str
);
904 line_buffer
[p
- str
] = '\0';
905 if (islower (line_buffer
[0]))
906 line_buffer
[0] = toupper (line_buffer
[0]);
907 ui_out_text (uiout
, line_buffer
);
911 * Implement a help command on command list LIST.
912 * RECURSE should be non-zero if this should be done recursively on
913 * all sublists of LIST.
914 * PREFIX is the prefix to print before each command name.
915 * STREAM is the stream upon which the output should be written.
917 * A non-negative class number to list only commands in that
919 * ALL_COMMANDS to list all commands in list.
920 * ALL_CLASSES to list all classes in list.
922 * Note that RECURSE will be active on *all* sublists, not just the
923 * ones selected by the criteria above (ie. the selection mechanism
924 * is at the low level, not the high-level).
927 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
928 char *prefix
, int recurse
, struct ui_file
*stream
)
930 struct cmd_list_element
*c
;
932 for (c
= list
; c
; c
= c
->next
)
934 if (c
->abbrev_flag
== 0 &&
935 (class == all_commands
936 || (class == all_classes
&& c
->func
== NULL
)
937 || (class == c
->class && c
->func
!= NULL
)))
939 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
940 print_doc_line (stream
, c
->doc
);
941 fputs_filtered ("\n", stream
);
944 && c
->prefixlist
!= 0
945 && c
->abbrev_flag
== 0)
946 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
, 1, stream
);
951 /* Search the input clist for 'command'. Return the command if
952 found (or NULL if not), and return the number of commands
955 static struct cmd_list_element
*
956 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
957 int ignore_help_classes
, int *nfound
)
959 struct cmd_list_element
*found
, *c
;
961 found
= (struct cmd_list_element
*) NULL
;
963 for (c
= clist
; c
; c
= c
->next
)
964 if (!strncmp (command
, c
->name
, len
)
965 && (!ignore_help_classes
|| c
->func
))
969 if (c
->name
[len
] == '\0')
978 /* This routine takes a line of TEXT and a CLIST in which to start the
979 lookup. When it returns it will have incremented the text pointer past
980 the section of text it matched, set *RESULT_LIST to point to the list in
981 which the last word was matched, and will return a pointer to the cmd
982 list element which the text matches. It will return NULL if no match at
983 all was possible. It will return -1 (cast appropriately, ick) if ambigous
984 matches are possible; in this case *RESULT_LIST will be set to point to
985 the list in which there are ambiguous choices (and *TEXT will be set to
986 the ambiguous text string).
988 If the located command was an abbreviation, this routine returns the base
989 command of the abbreviation.
991 It does no error reporting whatsoever; control will always return
992 to the superior routine.
994 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
995 at the prefix_command (ie. the best match) *or* (special case) will be NULL
996 if no prefix command was ever found. For example, in the case of "info a",
997 "info" matches without ambiguity, but "a" could be "args" or "address", so
998 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
999 RESULT_LIST should not be interpeted as a pointer to the beginning of a
1000 list; it simply points to a specific command. In the case of an ambiguous
1001 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1002 "info t" can be "info types" or "info target"; upon return *TEXT has been
1003 advanced past "info ").
1005 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1006 affect the operation).
1008 This routine does *not* modify the text pointed to by TEXT.
1010 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1011 are actually help classes rather than commands (i.e. the function field of
1012 the struct cmd_list_element is NULL). */
1014 struct cmd_list_element
*
1015 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
1016 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1019 int len
, tmp
, nfound
;
1020 struct cmd_list_element
*found
, *c
;
1023 while (**text
== ' ' || **text
== '\t')
1026 /* Treating underscores as part of command words is important
1027 so that "set args_foo()" doesn't get interpreted as
1028 "set args _foo()". */
1029 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1032 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1035 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1037 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1041 /* If nothing but whitespace, return 0. */
1047 /* *text and p now bracket the first command word to lookup (and
1048 it's length is len). We copy this into a local temporary */
1051 command
= (char *) alloca (len
+ 1);
1052 for (tmp
= 0; tmp
< len
; tmp
++)
1054 char x
= (*text
)[tmp
];
1057 command
[len
] = '\0';
1062 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1065 ** We didn't find the command in the entered case, so lower case it
1066 ** and search again.
1068 if (!found
|| nfound
== 0)
1070 for (tmp
= 0; tmp
< len
; tmp
++)
1072 char x
= command
[tmp
];
1073 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1075 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1078 /* If nothing matches, we have a simple failure. */
1084 if (result_list
!= NULL
)
1085 /* Will be modified in calling routine
1086 if we know what the prefix command is. */
1088 return (struct cmd_list_element
*) -1; /* Ambiguous. */
1091 /* We've matched something on this list. Move text pointer forward. */
1095 if (found
->cmd_pointer
)
1097 /* We drop the alias (abbreviation) in favor of the command it is
1098 pointing to. If the alias is deprecated, though, we need to
1099 warn the user about it before we drop it. Note that while we
1100 are warning about the alias, we may also warn about the command
1101 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1104 if (found
->flags
& DEPRECATED_WARN_USER
)
1105 deprecated_cmd_warning (&line
);
1106 found
= found
->cmd_pointer
;
1108 /* If we found a prefix command, keep looking. */
1110 if (found
->prefixlist
)
1112 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1113 ignore_help_classes
);
1116 /* Didn't find anything; this is as far as we got. */
1117 if (result_list
!= NULL
)
1118 *result_list
= clist
;
1121 else if (c
== (struct cmd_list_element
*) -1)
1123 /* We've gotten this far properly, but the next step
1124 is ambiguous. We need to set the result list to the best
1125 we've found (if an inferior hasn't already set it). */
1126 if (result_list
!= NULL
)
1128 /* This used to say *result_list = *found->prefixlist
1129 If that was correct, need to modify the documentation
1130 at the top of this function to clarify what is supposed
1132 *result_list
= found
;
1143 if (result_list
!= NULL
)
1144 *result_list
= clist
;
1149 /* All this hair to move the space to the front of cmdtype */
1152 undef_cmd_error (char *cmdtype
, char *q
)
1154 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1157 *cmdtype
? " " : "",
1158 (int) strlen (cmdtype
) - 1,
1162 /* Look up the contents of *LINE as a command in the command list LIST.
1163 LIST is a chain of struct cmd_list_element's.
1164 If it is found, return the struct cmd_list_element for that command
1165 and update *LINE to point after the command name, at the first argument.
1166 If not found, call error if ALLOW_UNKNOWN is zero
1167 otherwise (or if error returns) return zero.
1168 Call error if specified command is ambiguous,
1169 unless ALLOW_UNKNOWN is negative.
1170 CMDTYPE precedes the word "command" in the error message.
1172 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1173 elements which are actually help classes rather than commands (i.e.
1174 the function field of the struct cmd_list_element is 0). */
1176 struct cmd_list_element
*
1177 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1178 int allow_unknown
, int ignore_help_classes
)
1180 struct cmd_list_element
*last_list
= 0;
1181 struct cmd_list_element
*c
=
1182 lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1184 /* Note: Do not remove trailing whitespace here because this
1185 would be wrong for complete_command. Jim Kingdon */
1192 error (_("Lack of needed %scommand"), cmdtype
);
1195 char *p
= *line
, *q
;
1197 while (isalnum (*p
) || *p
== '-')
1200 q
= (char *) alloca (p
- *line
+ 1);
1201 strncpy (q
, *line
, p
- *line
);
1202 q
[p
- *line
] = '\0';
1203 undef_cmd_error (cmdtype
, q
);
1209 else if (c
== (struct cmd_list_element
*) -1)
1211 /* Ambigous. Local values should be off prefixlist or called
1213 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1215 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1216 struct cmd_list_element
*local_list
=
1217 (last_list
? *(last_list
->prefixlist
) : list
);
1219 if (local_allow_unknown
< 0)
1222 return last_list
; /* Found something. */
1224 return 0; /* Found nothing. */
1228 /* Report as error. */
1233 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1234 && (*line
)[amb_len
] != '\t');
1239 for (c
= local_list
; c
; c
= c
->next
)
1240 if (!strncmp (*line
, c
->name
, amb_len
))
1242 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1244 if (strlen (ambbuf
))
1245 strcat (ambbuf
, ", ");
1246 strcat (ambbuf
, c
->name
);
1250 strcat (ambbuf
, "..");
1254 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1256 return 0; /* lint */
1261 /* We've got something. It may still not be what the caller
1262 wants (if this command *needs* a subcommand). */
1263 while (**line
== ' ' || **line
== '\t')
1266 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1267 undef_cmd_error (c
->prefixname
, *line
);
1269 /* Seems to be what he wants. Return it. */
1275 /* We are here presumably because an alias or command in *TEXT is
1276 deprecated and a warning message should be generated. This function
1277 decodes *TEXT and potentially generates a warning message as outlined
1280 Example for 'set endian big' which has a fictitious alias 'seb'.
1282 If alias wasn't used in *TEXT, and the command is deprecated:
1283 "warning: 'set endian big' is deprecated."
1285 If alias was used, and only the alias is deprecated:
1286 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1288 If alias was used and command is deprecated (regardless of whether the
1289 alias itself is deprecated:
1291 "warning: 'set endian big' (seb) is deprecated."
1293 After the message has been sent, clear the appropriate flags in the
1294 command and/or the alias so the user is no longer bothered.
1298 deprecated_cmd_warning (char **text
)
1300 struct cmd_list_element
*alias
= NULL
;
1301 struct cmd_list_element
*prefix_cmd
= NULL
;
1302 struct cmd_list_element
*cmd
= NULL
;
1303 struct cmd_list_element
*c
;
1306 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1307 /* return if text doesn't evaluate to a command */
1310 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1311 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1312 /* return if nothing is deprecated */
1315 printf_filtered ("Warning:");
1317 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1318 printf_filtered (" '%s', an alias for the", alias
->name
);
1320 printf_filtered (" command '");
1323 printf_filtered ("%s", prefix_cmd
->prefixname
);
1325 printf_filtered ("%s", cmd
->name
);
1327 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1328 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1330 printf_filtered ("' is deprecated.\n");
1333 /* if it is only the alias that is deprecated, we want to indicate the
1334 new alias, otherwise we'll indicate the new command */
1336 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1338 if (alias
->replacement
)
1339 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1341 printf_filtered ("No alternative known.\n\n");
1345 if (cmd
->replacement
)
1346 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1348 printf_filtered ("No alternative known.\n\n");
1351 /* We've warned you, now we'll keep quiet */
1353 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1355 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1360 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1361 Return 1 on success, 0 on failure.
1363 If LINE refers to an alias, *alias will point to that alias.
1365 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1366 command) set *prefix_cmd.
1368 Set *cmd to point to the command LINE indicates.
1370 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1371 exist, they are NULL when we return.
1375 lookup_cmd_composition (char *text
,
1376 struct cmd_list_element
**alias
,
1377 struct cmd_list_element
**prefix_cmd
,
1378 struct cmd_list_element
**cmd
)
1381 int len
, tmp
, nfound
;
1382 struct cmd_list_element
*cur_list
;
1383 struct cmd_list_element
*prev_cmd
;
1392 /* Go through as many command lists as we need to
1393 to find the command TEXT refers to. */
1397 while (*text
== ' ' || *text
== '\t')
1400 /* Treating underscores as part of command words is important
1401 so that "set args_foo()" doesn't get interpreted as
1402 "set args _foo()". */
1403 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1406 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1409 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1411 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1415 /* If nothing but whitespace, return. */
1421 /* text and p now bracket the first command word to lookup (and
1422 it's length is len). We copy this into a local temporary */
1424 command
= (char *) alloca (len
+ 1);
1425 for (tmp
= 0; tmp
< len
; tmp
++)
1430 command
[len
] = '\0';
1435 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1437 /* We didn't find the command in the entered case, so lower case it
1440 if (!*cmd
|| nfound
== 0)
1442 for (tmp
= 0; tmp
< len
; tmp
++)
1444 char x
= command
[tmp
];
1445 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1447 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1450 if (*cmd
== (struct cmd_list_element
*) -1)
1452 return 0; /* ambiguous */
1456 return 0; /* nothing found */
1459 if ((*cmd
)->cmd_pointer
)
1461 /* cmd was actually an alias, we note that an alias was used
1462 (by assigning *alais) and we set *cmd.
1465 *cmd
= (*cmd
)->cmd_pointer
;
1467 *prefix_cmd
= prev_cmd
;
1469 if ((*cmd
)->prefixlist
)
1470 cur_list
= *(*cmd
)->prefixlist
;
1478 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1480 /* Return a vector of char pointers which point to the different
1481 possible completions in LIST of TEXT.
1483 WORD points in the same buffer as TEXT, and completions should be
1484 returned relative to this position. For example, suppose TEXT is "foo"
1485 and we want to complete to "foobar". If WORD is "oo", return
1486 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1489 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1491 struct cmd_list_element
*ptr
;
1493 int sizeof_matchlist
;
1495 int textlen
= strlen (text
);
1497 sizeof_matchlist
= 10;
1498 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1501 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1502 if (!strncmp (ptr
->name
, text
, textlen
)
1503 && !ptr
->abbrev_flag
1505 || ptr
->prefixlist
))
1507 if (matches
== sizeof_matchlist
)
1509 sizeof_matchlist
*= 2;
1510 matchlist
= (char **) xrealloc ((char *) matchlist
,
1512 * sizeof (char *)));
1515 matchlist
[matches
] = (char *)
1516 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1518 strcpy (matchlist
[matches
], ptr
->name
);
1519 else if (word
> text
)
1521 /* Return some portion of ptr->name. */
1522 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1526 /* Return some of text plus ptr->name. */
1527 strncpy (matchlist
[matches
], word
, text
- word
);
1528 matchlist
[matches
][text
- word
] = '\0';
1529 strcat (matchlist
[matches
], ptr
->name
);
1541 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1542 * sizeof (char *)));
1543 matchlist
[matches
] = (char *) 0;
1549 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1551 /* Return a vector of char pointers which point to the different
1552 possible completions in CMD of TEXT.
1554 WORD points in the same buffer as TEXT, and completions should be
1555 returned relative to this position. For example, suppose TEXT is "foo"
1556 and we want to complete to "foobar". If WORD is "oo", return
1557 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1560 complete_on_enum (const char *enumlist
[],
1565 int sizeof_matchlist
;
1567 int textlen
= strlen (text
);
1571 sizeof_matchlist
= 10;
1572 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1575 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1576 if (strncmp (name
, text
, textlen
) == 0)
1578 if (matches
== sizeof_matchlist
)
1580 sizeof_matchlist
*= 2;
1581 matchlist
= (char **) xrealloc ((char *) matchlist
,
1583 * sizeof (char *)));
1586 matchlist
[matches
] = (char *)
1587 xmalloc (strlen (word
) + strlen (name
) + 1);
1589 strcpy (matchlist
[matches
], name
);
1590 else if (word
> text
)
1592 /* Return some portion of name. */
1593 strcpy (matchlist
[matches
], name
+ (word
- text
));
1597 /* Return some of text plus name. */
1598 strncpy (matchlist
[matches
], word
, text
- word
);
1599 matchlist
[matches
][text
- word
] = '\0';
1600 strcat (matchlist
[matches
], name
);
1612 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1613 * sizeof (char *)));
1614 matchlist
[matches
] = (char *) 0;
1621 /* check function pointer */
1623 cmd_func_p (struct cmd_list_element
*cmd
)
1625 return (cmd
->func
!= NULL
);
1629 /* call the command function */
1631 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1633 if (cmd_func_p (cmd
))
1634 (*cmd
->func
) (cmd
, args
, from_tty
);
1636 error (_("Invalid command"));