1 /* Handle lists of commands, their decoding and documentation, for GDB.
3 Copyright 1986, 1989, 1990, 1991, 1998, 2000, 2001, 2002 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 and SHOW_DOC are the documentation strings.
324 SET_RESULT and SHOW_RESULT, if not NULL, are set to the resulting
325 command structures. */
328 add_setshow_cmd_full (char *name
,
329 enum command_class
class,
330 var_types var_type
, void *var
,
331 char *set_doc
, char *show_doc
,
332 cmd_sfunc_ftype
*set_func
, cmd_sfunc_ftype
*show_func
,
333 struct cmd_list_element
**set_list
,
334 struct cmd_list_element
**show_list
,
335 struct cmd_list_element
**set_result
,
336 struct cmd_list_element
**show_result
)
338 struct cmd_list_element
*set
;
339 struct cmd_list_element
*show
;
340 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
342 if (set_func
!= NULL
)
343 set_cmd_sfunc (set
, set_func
);
344 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
345 show_doc
, show_list
);
346 if (show_func
!= NULL
)
347 set_cmd_sfunc (show
, show_func
);
349 if (set_result
!= NULL
)
351 if (show_result
!= NULL
)
355 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
356 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
357 setting. VAR is address of the variable being controlled by this
358 command. SET_FUNC and SHOW_FUNC are the callback functions (if
359 non-NULL). SET_DOC and SHOW_DOC are the documentation strings. */
362 add_setshow_cmd (char *name
,
363 enum command_class
class,
364 var_types var_type
, void *var
,
365 char *set_doc
, char *show_doc
,
366 cmd_sfunc_ftype
*set_func
, cmd_sfunc_ftype
*show_func
,
367 struct cmd_list_element
**set_list
,
368 struct cmd_list_element
**show_list
)
370 add_setshow_cmd_full (name
, class, var_type
, var
, set_doc
, show_doc
,
371 set_func
, show_func
, set_list
, show_list
,
375 struct cmd_list_element
*
376 add_set_cmd (char *name
,
377 enum command_class
class,
381 struct cmd_list_element
**list
)
383 return add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
, doc
, list
);
386 /* Add element named NAME to command list LIST (the list for set
387 or some sublist thereof).
388 CLASS is as in add_cmd.
389 ENUMLIST is a list of strings which may follow NAME.
390 VAR is address of the variable which will contain the matching string
392 DOC is the documentation string. */
394 struct cmd_list_element
*
395 add_set_enum_cmd (char *name
,
396 enum command_class
class,
397 const char *enumlist
[],
400 struct cmd_list_element
**list
)
402 struct cmd_list_element
*c
403 = add_set_cmd (name
, class, var_enum
, var
, doc
, list
);
409 /* Add an auto-boolean command named NAME to both the set and show
410 command list lists. CLASS is as in add_cmd. VAR is address of the
411 variable which will contain the value. DOC is the documentation
412 string. FUNC is the corresponding callback. */
414 add_setshow_auto_boolean_cmd (char *name
,
415 enum command_class
class,
416 enum auto_boolean
*var
,
417 char *set_doc
, char *show_doc
,
418 cmd_sfunc_ftype
*set_func
,
419 cmd_sfunc_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
, set_func
, show_func
,
429 c
->enums
= auto_boolean_enums
;
432 /* Add element named NAME to both the set and show command LISTs (the
433 list for set/show or some sublist thereof). CLASS is as in
434 add_cmd. VAR is address of the variable which will contain the
435 value. SET_DOC and SHOW_DOC are the documentation strings. */
437 add_setshow_boolean_cmd (char *name
,
438 enum command_class
class,
439 int *var
, char *set_doc
, char *show_doc
,
440 cmd_sfunc_ftype
*set_func
,
441 cmd_sfunc_ftype
*show_func
,
442 struct cmd_list_element
**set_list
,
443 struct cmd_list_element
**show_list
)
445 static const char *boolean_enums
[] = { "on", "off", NULL
};
446 struct cmd_list_element
*c
;
447 add_setshow_cmd_full (name
, class, var_boolean
, var
,
452 c
->enums
= boolean_enums
;
455 /* Add element named NAME to both the set and show command LISTs (the
456 list for set/show or some sublist thereof). CLASS is as in
457 add_cmd. VAR is address of the variable which will contain the
458 value. SET_DOC and SHOW_DOC are the documentation strings. */
460 add_setshow_uinteger_cmd (char *name
,
461 enum command_class
class,
462 unsigned int *var
, char *set_doc
, char *show_doc
,
463 cmd_sfunc_ftype
*set_func
,
464 cmd_sfunc_ftype
*show_func
,
465 struct cmd_list_element
**set_list
,
466 struct cmd_list_element
**show_list
)
468 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
475 /* Add element named NAME to both the set and show command LISTs (the
476 list for set/show or some sublist thereof). CLASS is as in
477 add_cmd. VAR is address of the variable which will contain the
478 value. SET_DOC and SHOW_DOC are the documentation strings. */
480 add_setshow_zinteger_cmd (char *name
,
481 enum command_class
class,
482 int *var
, char *set_doc
, char *show_doc
,
483 cmd_sfunc_ftype
*set_func
,
484 cmd_sfunc_ftype
*show_func
,
485 struct cmd_list_element
**set_list
,
486 struct cmd_list_element
**show_list
)
488 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
495 /* Where SETCMD has already been added, add the corresponding show
496 command to LIST and return a pointer to the added command (not
497 necessarily the head of LIST). */
498 /* NOTE: cagney/2002-03-17: The original version of
499 deprecated_add_show_from_set used memcpy() to clone `set' into
500 `show'. This meant that in addition to all the needed fields (var,
501 name, et.al.) some unnecessary fields were copied (namely the
502 callback function). The function explictly copies relevant fields.
503 For a `set' and `show' command to share the same callback, the
504 caller must set both explicitly. */
505 struct cmd_list_element
*
506 deprecated_add_show_from_set (struct cmd_list_element
*setcmd
,
507 struct cmd_list_element
**list
)
510 const static char setstring
[] = "Set ";
512 /* Create a doc string by replacing "Set " at the start of the
513 `set'' command's doco with "Show ". */
514 gdb_assert (strncmp (setcmd
->doc
, setstring
, sizeof (setstring
) - 1) == 0);
515 doc
= concat ("Show ", setcmd
->doc
+ sizeof (setstring
) - 1, NULL
);
517 /* Insert the basic command. */
518 return add_set_or_show_cmd (setcmd
->name
, show_cmd
, setcmd
->class,
519 setcmd
->var_type
, setcmd
->var
, doc
, list
);
522 /* Remove the command named NAME from the command list. */
525 delete_cmd (char *name
, struct cmd_list_element
**list
)
527 struct cmd_list_element
*c
;
528 struct cmd_list_element
*p
;
530 while (*list
&& strcmp ((*list
)->name
, name
) == 0)
532 if ((*list
)->hookee_pre
)
533 (*list
)->hookee_pre
->hook_pre
= 0; /* Hook slips out of its mouth */
534 if ((*list
)->hookee_post
)
535 (*list
)->hookee_post
->hook_post
= 0; /* Hook slips out of its bottom */
542 for (c
= *list
; c
->next
;)
544 if (strcmp (c
->next
->name
, name
) == 0)
546 if (c
->next
->hookee_pre
)
547 c
->next
->hookee_pre
->hook_pre
= 0; /* hooked cmd gets away. */
548 if (c
->next
->hookee_post
)
549 c
->next
->hookee_post
->hook_post
= 0; /* remove post hook */
550 /* :( no fishing metaphore */
560 /* Shorthands to the commands above. */
562 /* Add an element to the list of info subcommands. */
564 struct cmd_list_element
*
565 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
567 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
570 /* Add an alias to the list of info subcommands. */
572 struct cmd_list_element
*
573 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
575 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
578 /* Add an element to the list of commands. */
580 struct cmd_list_element
*
581 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
584 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
587 /* Add an alias or abbreviation command to the list of commands. */
589 struct cmd_list_element
*
590 add_com_alias (char *name
, char *oldname
, enum command_class
class,
593 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
596 /* Recursively walk the commandlist structures, and print out the
597 documentation of commands that match our regex in either their
598 name, or their documentation.
601 apropos_cmd (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
602 struct re_pattern_buffer
*regex
, char *prefix
)
604 struct cmd_list_element
*c
;
605 int returnvalue
=1; /*Needed to avoid double printing*/
606 /* Walk through the commands */
607 for (c
=commandlist
;c
;c
=c
->next
)
611 /* Try to match against the name*/
612 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
613 if (returnvalue
>= 0)
615 /* Stolen from help_cmd_list. We don't directly use
616 * help_cmd_list because it doesn't let us print out
619 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
620 print_doc_line (stream
, c
->doc
);
621 fputs_filtered ("\n", stream
);
622 returnvalue
=0; /*Set this so we don't print it again.*/
625 if (c
->doc
!= NULL
&& returnvalue
!= 0)
627 /* Try to match against documentation */
628 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
630 /* Stolen from help_cmd_list. We don't directly use
631 * help_cmd_list because it doesn't let us print out
634 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
635 print_doc_line (stream
, c
->doc
);
636 fputs_filtered ("\n", stream
);
639 /* Check if this command has subcommands */
640 if (c
->prefixlist
!= NULL
)
642 /* Recursively call ourselves on the subcommand list,
643 passing the right prefix in.
645 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
650 /* This command really has to deal with two things:
651 * 1) I want documentation on *this string* (usually called by
652 * "help commandname").
653 * 2) I want documentation on *this list* (usually called by
654 * giving a command that requires subcommands. Also called by saying
657 * I am going to split this into two seperate comamnds, help_cmd and
662 help_cmd (char *command
, struct ui_file
*stream
)
664 struct cmd_list_element
*c
;
665 extern struct cmd_list_element
*cmdlist
;
669 help_list (cmdlist
, "", all_classes
, stream
);
673 if (strcmp (command
, "all") == 0)
679 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
684 /* There are three cases here.
685 If c->prefixlist is nonzero, we have a prefix command.
686 Print its documentation, then list its subcommands.
688 If c->func is non NULL, we really have a command. Print its
689 documentation and return.
691 If c->func is NULL, we have a class name. Print its
692 documentation (as if it were a command) and then set class to the
693 number of this class so that the commands in the class will be
696 fputs_filtered (c
->doc
, stream
);
697 fputs_filtered ("\n", stream
);
699 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
701 fprintf_filtered (stream
, "\n");
703 /* If this is a prefix command, print it's subcommands */
705 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
707 /* If this is a class name, print all of the commands in the class */
709 help_list (cmdlist
, "", c
->class, stream
);
711 if (c
->hook_pre
|| c
->hook_post
)
712 fprintf_filtered (stream
,
713 "\nThis command has a hook (or hooks) defined:\n");
716 fprintf_filtered (stream
,
717 "\tThis command is run after : %s (pre hook)\n",
720 fprintf_filtered (stream
,
721 "\tThis command is run before : %s (post hook)\n",
726 * Get a specific kind of help on a command list.
729 * CMDTYPE is the prefix to use in the title string.
730 * CLASS is the class with which to list the nodes of this list (see
731 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
732 * everything, ALL_CLASSES for just classes, and non-negative for only things
733 * in a specific class.
734 * and STREAM is the output stream on which to print things.
735 * If you call this routine with a class >= 0, it recurses.
738 help_list (struct cmd_list_element
*list
, char *cmdtype
,
739 enum command_class
class, struct ui_file
*stream
)
742 char *cmdtype1
, *cmdtype2
;
744 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
745 len
= strlen (cmdtype
);
746 cmdtype1
= (char *) alloca (len
+ 1);
748 cmdtype2
= (char *) alloca (len
+ 4);
753 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
755 strncpy (cmdtype2
, cmdtype
, len
- 1);
756 strcpy (cmdtype2
+ len
- 1, " sub");
759 if (class == all_classes
)
760 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
762 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
764 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
766 if (class == all_classes
)
768 fprintf_filtered (stream
, "\n\
769 Type \"help%s\" followed by a class name for a list of commands in ",
772 fprintf_filtered (stream
, "that class.");
775 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
778 fputs_filtered ("for ", stream
);
780 fputs_filtered ("full ", stream
);
782 fputs_filtered ("documentation.\n", stream
);
783 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
788 help_all (struct ui_file
*stream
)
790 struct cmd_list_element
*c
;
791 extern struct cmd_list_element
*cmdlist
;
793 for (c
= cmdlist
; c
; c
= c
->next
)
797 /* If this is a prefix command, print it's subcommands */
799 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 0, stream
);
801 /* If this is a class name, print all of the commands in the class */
802 else if (c
->func
== NULL
)
803 help_cmd_list (cmdlist
, c
->class, "", 0, stream
);
807 /* Print only the first line of STR on STREAM. */
809 print_doc_line (struct ui_file
*stream
, char *str
)
811 static char *line_buffer
= 0;
812 static int line_size
;
818 line_buffer
= (char *) xmalloc (line_size
);
822 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
824 if (p
- str
> line_size
- 1)
826 line_size
= p
- str
+ 1;
828 line_buffer
= (char *) xmalloc (line_size
);
830 strncpy (line_buffer
, str
, p
- str
);
831 line_buffer
[p
- str
] = '\0';
832 if (islower (line_buffer
[0]))
833 line_buffer
[0] = toupper (line_buffer
[0]);
834 ui_out_text (uiout
, line_buffer
);
838 * Implement a help command on command list LIST.
839 * RECURSE should be non-zero if this should be done recursively on
840 * all sublists of LIST.
841 * PREFIX is the prefix to print before each command name.
842 * STREAM is the stream upon which the output should be written.
844 * A non-negative class number to list only commands in that
846 * ALL_COMMANDS to list all commands in list.
847 * ALL_CLASSES to list all classes in list.
849 * Note that RECURSE will be active on *all* sublists, not just the
850 * ones selected by the criteria above (ie. the selection mechanism
851 * is at the low level, not the high-level).
854 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
855 char *prefix
, int recurse
, struct ui_file
*stream
)
857 struct cmd_list_element
*c
;
859 for (c
= list
; c
; c
= c
->next
)
861 if (c
->abbrev_flag
== 0 &&
862 (class == all_commands
863 || (class == all_classes
&& c
->func
== NULL
)
864 || (class == c
->class && c
->func
!= NULL
)))
866 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
867 print_doc_line (stream
, c
->doc
);
868 fputs_filtered ("\n", stream
);
871 && c
->prefixlist
!= 0
872 && c
->abbrev_flag
== 0)
873 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
, 1, stream
);
878 /* Search the input clist for 'command'. Return the command if
879 found (or NULL if not), and return the number of commands
882 static struct cmd_list_element
*
883 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
884 int ignore_help_classes
, int *nfound
)
886 struct cmd_list_element
*found
, *c
;
888 found
= (struct cmd_list_element
*) NULL
;
890 for (c
= clist
; c
; c
= c
->next
)
891 if (!strncmp (command
, c
->name
, len
)
892 && (!ignore_help_classes
|| c
->func
))
896 if (c
->name
[len
] == '\0')
905 /* This routine takes a line of TEXT and a CLIST in which to start the
906 lookup. When it returns it will have incremented the text pointer past
907 the section of text it matched, set *RESULT_LIST to point to the list in
908 which the last word was matched, and will return a pointer to the cmd
909 list element which the text matches. It will return NULL if no match at
910 all was possible. It will return -1 (cast appropriately, ick) if ambigous
911 matches are possible; in this case *RESULT_LIST will be set to point to
912 the list in which there are ambiguous choices (and *TEXT will be set to
913 the ambiguous text string).
915 If the located command was an abbreviation, this routine returns the base
916 command of the abbreviation.
918 It does no error reporting whatsoever; control will always return
919 to the superior routine.
921 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
922 at the prefix_command (ie. the best match) *or* (special case) will be NULL
923 if no prefix command was ever found. For example, in the case of "info a",
924 "info" matches without ambiguity, but "a" could be "args" or "address", so
925 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
926 RESULT_LIST should not be interpeted as a pointer to the beginning of a
927 list; it simply points to a specific command. In the case of an ambiguous
928 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
929 "info t" can be "info types" or "info target"; upon return *TEXT has been
930 advanced past "info ").
932 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
933 affect the operation).
935 This routine does *not* modify the text pointed to by TEXT.
937 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
938 are actually help classes rather than commands (i.e. the function field of
939 the struct cmd_list_element is NULL). */
941 struct cmd_list_element
*
942 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
943 struct cmd_list_element
**result_list
, int ignore_help_classes
)
946 int len
, tmp
, nfound
;
947 struct cmd_list_element
*found
, *c
;
950 while (**text
== ' ' || **text
== '\t')
953 /* Treating underscores as part of command words is important
954 so that "set args_foo()" doesn't get interpreted as
955 "set args _foo()". */
956 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
959 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
962 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
964 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
968 /* If nothing but whitespace, return 0. */
974 /* *text and p now bracket the first command word to lookup (and
975 it's length is len). We copy this into a local temporary */
978 command
= (char *) alloca (len
+ 1);
979 for (tmp
= 0; tmp
< len
; tmp
++)
981 char x
= (*text
)[tmp
];
989 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
992 ** We didn't find the command in the entered case, so lower case it
995 if (!found
|| nfound
== 0)
997 for (tmp
= 0; tmp
< len
; tmp
++)
999 char x
= command
[tmp
];
1000 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1002 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1005 /* If nothing matches, we have a simple failure. */
1011 if (result_list
!= NULL
)
1012 /* Will be modified in calling routine
1013 if we know what the prefix command is. */
1015 return (struct cmd_list_element
*) -1; /* Ambiguous. */
1018 /* We've matched something on this list. Move text pointer forward. */
1022 if (found
->cmd_pointer
)
1024 /* We drop the alias (abbreviation) in favor of the command it is
1025 pointing to. If the alias is deprecated, though, we need to
1026 warn the user about it before we drop it. Note that while we
1027 are warning about the alias, we may also warn about the command
1028 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1031 if (found
->flags
& DEPRECATED_WARN_USER
)
1032 deprecated_cmd_warning (&line
);
1033 found
= found
->cmd_pointer
;
1035 /* If we found a prefix command, keep looking. */
1037 if (found
->prefixlist
)
1039 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1040 ignore_help_classes
);
1043 /* Didn't find anything; this is as far as we got. */
1044 if (result_list
!= NULL
)
1045 *result_list
= clist
;
1048 else if (c
== (struct cmd_list_element
*) -1)
1050 /* We've gotten this far properly, but the next step
1051 is ambiguous. We need to set the result list to the best
1052 we've found (if an inferior hasn't already set it). */
1053 if (result_list
!= NULL
)
1055 /* This used to say *result_list = *found->prefixlist
1056 If that was correct, need to modify the documentation
1057 at the top of this function to clarify what is supposed
1059 *result_list
= found
;
1070 if (result_list
!= NULL
)
1071 *result_list
= clist
;
1076 /* All this hair to move the space to the front of cmdtype */
1079 undef_cmd_error (char *cmdtype
, char *q
)
1081 error ("Undefined %scommand: \"%s\". Try \"help%s%.*s\".",
1084 *cmdtype
? " " : "",
1085 (int) strlen (cmdtype
) - 1,
1089 /* Look up the contents of *LINE as a command in the command list LIST.
1090 LIST is a chain of struct cmd_list_element's.
1091 If it is found, return the struct cmd_list_element for that command
1092 and update *LINE to point after the command name, at the first argument.
1093 If not found, call error if ALLOW_UNKNOWN is zero
1094 otherwise (or if error returns) return zero.
1095 Call error if specified command is ambiguous,
1096 unless ALLOW_UNKNOWN is negative.
1097 CMDTYPE precedes the word "command" in the error message.
1099 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1100 elements which are actually help classes rather than commands (i.e.
1101 the function field of the struct cmd_list_element is 0). */
1103 struct cmd_list_element
*
1104 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1105 int allow_unknown
, int ignore_help_classes
)
1107 struct cmd_list_element
*last_list
= 0;
1108 struct cmd_list_element
*c
=
1109 lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1111 /* Note: Do not remove trailing whitespace here because this
1112 would be wrong for complete_command. Jim Kingdon */
1119 error ("Lack of needed %scommand", cmdtype
);
1122 char *p
= *line
, *q
;
1124 while (isalnum (*p
) || *p
== '-')
1127 q
= (char *) alloca (p
- *line
+ 1);
1128 strncpy (q
, *line
, p
- *line
);
1129 q
[p
- *line
] = '\0';
1130 undef_cmd_error (cmdtype
, q
);
1136 else if (c
== (struct cmd_list_element
*) -1)
1138 /* Ambigous. Local values should be off prefixlist or called
1140 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1142 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1143 struct cmd_list_element
*local_list
=
1144 (last_list
? *(last_list
->prefixlist
) : list
);
1146 if (local_allow_unknown
< 0)
1149 return last_list
; /* Found something. */
1151 return 0; /* Found nothing. */
1155 /* Report as error. */
1160 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1161 && (*line
)[amb_len
] != '\t');
1166 for (c
= local_list
; c
; c
= c
->next
)
1167 if (!strncmp (*line
, c
->name
, amb_len
))
1169 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1171 if (strlen (ambbuf
))
1172 strcat (ambbuf
, ", ");
1173 strcat (ambbuf
, c
->name
);
1177 strcat (ambbuf
, "..");
1181 error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype
,
1183 return 0; /* lint */
1188 /* We've got something. It may still not be what the caller
1189 wants (if this command *needs* a subcommand). */
1190 while (**line
== ' ' || **line
== '\t')
1193 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1194 undef_cmd_error (c
->prefixname
, *line
);
1196 /* Seems to be what he wants. Return it. */
1202 /* We are here presumably because an alias or command in *TEXT is
1203 deprecated and a warning message should be generated. This function
1204 decodes *TEXT and potentially generates a warning message as outlined
1207 Example for 'set endian big' which has a fictitious alias 'seb'.
1209 If alias wasn't used in *TEXT, and the command is deprecated:
1210 "warning: 'set endian big' is deprecated."
1212 If alias was used, and only the alias is deprecated:
1213 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1215 If alias was used and command is deprecated (regardless of whether the
1216 alias itself is deprecated:
1218 "warning: 'set endian big' (seb) is deprecated."
1220 After the message has been sent, clear the appropriate flags in the
1221 command and/or the alias so the user is no longer bothered.
1225 deprecated_cmd_warning (char **text
)
1227 struct cmd_list_element
*alias
= NULL
;
1228 struct cmd_list_element
*prefix_cmd
= NULL
;
1229 struct cmd_list_element
*cmd
= NULL
;
1230 struct cmd_list_element
*c
;
1233 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1234 /* return if text doesn't evaluate to a command */
1237 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1238 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1239 /* return if nothing is deprecated */
1242 printf_filtered ("Warning:");
1244 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1245 printf_filtered (" '%s', an alias for the", alias
->name
);
1247 printf_filtered (" command '");
1250 printf_filtered ("%s", prefix_cmd
->prefixname
);
1252 printf_filtered ("%s", cmd
->name
);
1254 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1255 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1257 printf_filtered ("' is deprecated.\n");
1260 /* if it is only the alias that is deprecated, we want to indicate the
1261 new alias, otherwise we'll indicate the new command */
1263 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1265 if (alias
->replacement
)
1266 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1268 printf_filtered ("No alternative known.\n\n");
1272 if (cmd
->replacement
)
1273 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1275 printf_filtered ("No alternative known.\n\n");
1278 /* We've warned you, now we'll keep quiet */
1280 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1282 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1287 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1288 Return 1 on success, 0 on failure.
1290 If LINE refers to an alias, *alias will point to that alias.
1292 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1293 command) set *prefix_cmd.
1295 Set *cmd to point to the command LINE indicates.
1297 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1298 exist, they are NULL when we return.
1302 lookup_cmd_composition (char *text
,
1303 struct cmd_list_element
**alias
,
1304 struct cmd_list_element
**prefix_cmd
,
1305 struct cmd_list_element
**cmd
)
1308 int len
, tmp
, nfound
;
1309 struct cmd_list_element
*cur_list
;
1310 struct cmd_list_element
*prev_cmd
;
1319 /* Go through as many command lists as we need to
1320 to find the command TEXT refers to. */
1324 while (*text
== ' ' || *text
== '\t')
1327 /* Treating underscores as part of command words is important
1328 so that "set args_foo()" doesn't get interpreted as
1329 "set args _foo()". */
1330 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1333 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1336 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1338 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1342 /* If nothing but whitespace, return. */
1348 /* text and p now bracket the first command word to lookup (and
1349 it's length is len). We copy this into a local temporary */
1351 command
= (char *) alloca (len
+ 1);
1352 for (tmp
= 0; tmp
< len
; tmp
++)
1357 command
[len
] = '\0';
1362 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1364 /* We didn't find the command in the entered case, so lower case it
1367 if (!*cmd
|| nfound
== 0)
1369 for (tmp
= 0; tmp
< len
; tmp
++)
1371 char x
= command
[tmp
];
1372 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1374 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1377 if (*cmd
== (struct cmd_list_element
*) -1)
1379 return 0; /* ambiguous */
1383 return 0; /* nothing found */
1386 if ((*cmd
)->cmd_pointer
)
1388 /* cmd was actually an alias, we note that an alias was used
1389 (by assigning *alais) and we set *cmd.
1392 *cmd
= (*cmd
)->cmd_pointer
;
1394 *prefix_cmd
= prev_cmd
;
1396 if ((*cmd
)->prefixlist
)
1397 cur_list
= *(*cmd
)->prefixlist
;
1405 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1407 /* Return a vector of char pointers which point to the different
1408 possible completions in LIST of TEXT.
1410 WORD points in the same buffer as TEXT, and completions should be
1411 returned relative to this position. For example, suppose TEXT is "foo"
1412 and we want to complete to "foobar". If WORD is "oo", return
1413 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1416 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1418 struct cmd_list_element
*ptr
;
1420 int sizeof_matchlist
;
1422 int textlen
= strlen (text
);
1424 sizeof_matchlist
= 10;
1425 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1428 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1429 if (!strncmp (ptr
->name
, text
, textlen
)
1430 && !ptr
->abbrev_flag
1432 || ptr
->prefixlist
))
1434 if (matches
== sizeof_matchlist
)
1436 sizeof_matchlist
*= 2;
1437 matchlist
= (char **) xrealloc ((char *) matchlist
,
1439 * sizeof (char *)));
1442 matchlist
[matches
] = (char *)
1443 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1445 strcpy (matchlist
[matches
], ptr
->name
);
1446 else if (word
> text
)
1448 /* Return some portion of ptr->name. */
1449 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1453 /* Return some of text plus ptr->name. */
1454 strncpy (matchlist
[matches
], word
, text
- word
);
1455 matchlist
[matches
][text
- word
] = '\0';
1456 strcat (matchlist
[matches
], ptr
->name
);
1468 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1469 * sizeof (char *)));
1470 matchlist
[matches
] = (char *) 0;
1476 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1478 /* Return a vector of char pointers which point to the different
1479 possible completions in CMD of TEXT.
1481 WORD points in the same buffer as TEXT, and completions should be
1482 returned relative to this position. For example, suppose TEXT is "foo"
1483 and we want to complete to "foobar". If WORD is "oo", return
1484 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1487 complete_on_enum (const char *enumlist
[],
1492 int sizeof_matchlist
;
1494 int textlen
= strlen (text
);
1498 sizeof_matchlist
= 10;
1499 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1502 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1503 if (strncmp (name
, text
, textlen
) == 0)
1505 if (matches
== sizeof_matchlist
)
1507 sizeof_matchlist
*= 2;
1508 matchlist
= (char **) xrealloc ((char *) matchlist
,
1510 * sizeof (char *)));
1513 matchlist
[matches
] = (char *)
1514 xmalloc (strlen (word
) + strlen (name
) + 1);
1516 strcpy (matchlist
[matches
], name
);
1517 else if (word
> text
)
1519 /* Return some portion of name. */
1520 strcpy (matchlist
[matches
], name
+ (word
- text
));
1524 /* Return some of text plus name. */
1525 strncpy (matchlist
[matches
], word
, text
- word
);
1526 matchlist
[matches
][text
- word
] = '\0';
1527 strcat (matchlist
[matches
], name
);
1539 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1540 * sizeof (char *)));
1541 matchlist
[matches
] = (char *) 0;
1548 /* check function pointer */
1550 cmd_func_p (struct cmd_list_element
*cmd
)
1552 return (cmd
->func
!= NULL
);
1556 /* call the command function */
1558 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1560 if (cmd_func_p (cmd
))
1561 (*cmd
->func
) (cmd
, args
, from_tty
);
1563 error ("Invalid command");