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"
32 #include "gdb_assert.h"
34 /* Prototypes for local functions */
36 static void undef_cmd_error (char *, char *);
38 static struct cmd_list_element
*find_cmd (char *command
,
40 struct cmd_list_element
*clist
,
41 int ignore_help_classes
,
44 static void help_all (struct ui_file
*stream
);
46 /* Set the callback function for the specified command. For each both
47 the commands callback and func() are set. The latter set to a
48 bounce function (unless cfunc / sfunc is NULL that is). */
51 do_cfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
53 c
->function
.cfunc (args
, from_tty
); /* Ok. */
57 set_cmd_cfunc (struct cmd_list_element
*cmd
, cmd_cfunc_ftype
*cfunc
)
63 cmd
->function
.cfunc
= cfunc
; /* Ok. */
67 do_sfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
69 c
->function
.sfunc (args
, from_tty
, c
); /* Ok. */
73 set_cmd_sfunc (struct cmd_list_element
*cmd
, cmd_sfunc_ftype
*sfunc
)
79 cmd
->function
.sfunc
= sfunc
; /* Ok. */
83 cmd_cfunc_eq (struct cmd_list_element
*cmd
,
84 void (*cfunc
) (char *args
, int from_tty
))
86 return cmd
->func
== do_cfunc
&& cmd
->function
.cfunc
== cfunc
;
90 set_cmd_context (struct cmd_list_element
*cmd
, void *context
)
92 cmd
->context
= context
;
96 get_cmd_context (struct cmd_list_element
*cmd
)
102 cmd_type (struct cmd_list_element
*cmd
)
108 set_cmd_completer (struct cmd_list_element
*cmd
,
109 char **(*completer
) (char *text
, char *word
))
111 cmd
->completer
= completer
; /* Ok. */
115 /* Add element named NAME.
116 CLASS is the top level category into which commands are broken down
118 FUN should be the function to execute the command;
119 it will get a character string as argument, with leading
120 and trailing blanks already eliminated.
122 DOC is a documentation string for the command.
123 Its first line should be a complete sentence.
124 It should start with ? for a command that is an abbreviation
125 or with * for a command that most users don't need to know about.
127 Add this command to command list *LIST.
129 Returns a pointer to the added command (not necessarily the head
132 struct cmd_list_element
*
133 add_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
134 char *doc
, struct cmd_list_element
**list
)
136 register struct cmd_list_element
*c
137 = (struct cmd_list_element
*) xmalloc (sizeof (struct cmd_list_element
));
138 struct cmd_list_element
*p
;
140 delete_cmd (name
, list
);
142 if (*list
== NULL
|| strcmp ((*list
)->name
, name
) >= 0)
150 while (p
->next
&& strcmp (p
->next
->name
, name
) <= 0)
160 set_cmd_cfunc (c
, fun
);
161 set_cmd_context (c
, NULL
);
164 c
->replacement
= NULL
;
165 c
->pre_show_hook
= NULL
;
169 c
->prefixlist
= NULL
;
170 c
->prefixname
= NULL
;
171 c
->allow_unknown
= 0;
173 set_cmd_completer (c
, make_symbol_completion_list
);
174 c
->type
= not_set_cmd
;
176 c
->var_type
= var_boolean
;
178 c
->user_commands
= NULL
;
179 c
->hookee_pre
= NULL
;
180 c
->hookee_post
= NULL
;
181 c
->cmd_pointer
= NULL
;
186 /* Deprecates a command CMD.
187 REPLACEMENT is the name of the command which should be used in place
188 of this command, or NULL if no such command exists.
190 This function does not check to see if command REPLACEMENT exists
191 since gdb may not have gotten around to adding REPLACEMENT when this
194 Returns a pointer to the deprecated command. */
196 struct cmd_list_element
*
197 deprecate_cmd (struct cmd_list_element
*cmd
, char *replacement
)
199 cmd
->flags
|= (CMD_DEPRECATED
| DEPRECATED_WARN_USER
);
201 if (replacement
!= NULL
)
202 cmd
->replacement
= replacement
;
204 cmd
->replacement
= NULL
;
209 struct cmd_list_element
*
210 add_alias_cmd (char *name
, char *oldname
, enum command_class
class,
211 int abbrev_flag
, struct cmd_list_element
**list
)
213 /* Must do this since lookup_cmd tries to side-effect its first arg */
215 register struct cmd_list_element
*old
;
216 register struct cmd_list_element
*c
;
217 copied_name
= (char *) alloca (strlen (oldname
) + 1);
218 strcpy (copied_name
, oldname
);
219 old
= lookup_cmd (&copied_name
, *list
, "", 1, 1);
223 delete_cmd (name
, list
);
227 c
= add_cmd (name
, class, NULL
, old
->doc
, list
);
228 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
230 c
->function
= old
->function
;
231 c
->prefixlist
= old
->prefixlist
;
232 c
->prefixname
= old
->prefixname
;
233 c
->allow_unknown
= old
->allow_unknown
;
234 c
->abbrev_flag
= abbrev_flag
;
235 c
->cmd_pointer
= old
;
239 /* Like add_cmd but adds an element for a command prefix:
240 a name that should be followed by a subcommand to be looked up
241 in another command list. PREFIXLIST should be the address
242 of the variable containing that list. */
244 struct cmd_list_element
*
245 add_prefix_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
246 char *doc
, struct cmd_list_element
**prefixlist
,
247 char *prefixname
, int allow_unknown
,
248 struct cmd_list_element
**list
)
250 register struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
251 c
->prefixlist
= prefixlist
;
252 c
->prefixname
= prefixname
;
253 c
->allow_unknown
= allow_unknown
;
257 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
259 struct cmd_list_element
*
260 add_abbrev_prefix_cmd (char *name
, enum command_class
class,
261 void (*fun
) (char *, int), char *doc
,
262 struct cmd_list_element
**prefixlist
, char *prefixname
,
263 int allow_unknown
, struct cmd_list_element
**list
)
265 register struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
266 c
->prefixlist
= prefixlist
;
267 c
->prefixname
= prefixname
;
268 c
->allow_unknown
= allow_unknown
;
273 /* This is an empty "cfunc". */
275 not_just_help_class_command (char *args
, int from_tty
)
279 /* This is an empty "sfunc". */
280 static void empty_sfunc (char *, int, struct cmd_list_element
*);
283 empty_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
287 /* Add element named NAME to command list LIST (the list for set/show
288 or some sublist thereof).
289 TYPE is set_cmd or show_cmd.
290 CLASS is as in add_cmd.
291 VAR_TYPE is the kind of thing we are setting.
292 VAR is address of the variable being controlled by this command.
293 DOC is the documentation string. */
295 static struct cmd_list_element
*
296 add_set_or_show_cmd (char *name
,
298 enum command_class
class,
302 struct cmd_list_element
**list
)
304 struct cmd_list_element
*c
= add_cmd (name
, class, NULL
, doc
, list
);
305 gdb_assert (type
== set_cmd
|| type
== show_cmd
);
307 c
->var_type
= var_type
;
309 /* This needs to be something besides NULL so that this isn't
310 treated as a help class. */
311 set_cmd_sfunc (c
, empty_sfunc
);
315 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
316 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
317 setting. VAR is address of the variable being controlled by this
318 command. SET_FUNC and SHOW_FUNC are the callback functions (if
319 non-NULL). SET_DOC and SHOW_DOC are the documentation strings.
320 SET_RESULT and SHOW_RESULT, if not NULL, are set to the resulting
321 command structures. */
324 add_setshow_cmd_full (char *name
,
325 enum command_class
class,
326 var_types var_type
, void *var
,
327 char *set_doc
, char *show_doc
,
328 cmd_sfunc_ftype
*set_func
, cmd_sfunc_ftype
*show_func
,
329 struct cmd_list_element
**set_list
,
330 struct cmd_list_element
**show_list
,
331 struct cmd_list_element
**set_result
,
332 struct cmd_list_element
**show_result
)
334 struct cmd_list_element
*set
;
335 struct cmd_list_element
*show
;
336 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
338 if (set_func
!= NULL
)
339 set_cmd_sfunc (set
, set_func
);
340 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
341 show_doc
, show_list
);
342 if (show_func
!= NULL
)
343 set_cmd_sfunc (show
, show_func
);
345 if (set_result
!= NULL
)
347 if (show_result
!= NULL
)
351 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
352 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
353 setting. VAR is address of the variable being controlled by this
354 command. SET_FUNC and SHOW_FUNC are the callback functions (if
355 non-NULL). SET_DOC and SHOW_DOC are the documentation strings. */
358 add_setshow_cmd (char *name
,
359 enum command_class
class,
360 var_types var_type
, void *var
,
361 char *set_doc
, char *show_doc
,
362 cmd_sfunc_ftype
*set_func
, cmd_sfunc_ftype
*show_func
,
363 struct cmd_list_element
**set_list
,
364 struct cmd_list_element
**show_list
)
366 add_setshow_cmd_full (name
, class, var_type
, var
, set_doc
, show_doc
,
367 set_func
, show_func
, set_list
, show_list
,
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 an auto-boolean command named NAME to both the set and show
406 command list lists. CLASS is as in add_cmd. VAR is address of the
407 variable which will contain the value. DOC is the documentation
408 string. FUNC is the corresponding callback. */
410 add_setshow_auto_boolean_cmd (char *name
,
411 enum command_class
class,
412 enum auto_boolean
*var
,
413 char *set_doc
, char *show_doc
,
414 cmd_sfunc_ftype
*set_func
,
415 cmd_sfunc_ftype
*show_func
,
416 struct cmd_list_element
**set_list
,
417 struct cmd_list_element
**show_list
)
419 static const char *auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
420 struct cmd_list_element
*c
;
421 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
422 set_doc
, show_doc
, set_func
, show_func
,
425 c
->enums
= auto_boolean_enums
;
428 /* Add element named NAME to both the set and show command LISTs (the
429 list for set/show or some sublist thereof). CLASS is as in
430 add_cmd. VAR is address of the variable which will contain the
431 value. SET_DOC and SHOW_DOR are the documentation strings. */
433 add_setshow_boolean_cmd (char *name
,
434 enum command_class
class,
435 int *var
, char *set_doc
, char *show_doc
,
436 cmd_sfunc_ftype
*set_func
,
437 cmd_sfunc_ftype
*show_func
,
438 struct cmd_list_element
**set_list
,
439 struct cmd_list_element
**show_list
)
441 static const char *boolean_enums
[] = { "on", "off", NULL
};
442 struct cmd_list_element
*c
;
443 add_setshow_cmd_full (name
, class, var_boolean
, var
,
448 c
->enums
= boolean_enums
;
451 /* Where SETCMD has already been added, add the corresponding show
452 command to LIST and return a pointer to the added command (not
453 necessarily the head of LIST). */
454 /* NOTE: cagney/2002-03-17: The original version of add_show_from_set
455 used memcpy() to clone `set' into `show'. This meant that in
456 addition to all the needed fields (var, name, et.al.) some
457 unnecessary fields were copied (namely the callback function). The
458 function explictly copies relevant fields. For a `set' and `show'
459 command to share the same callback, the caller must set both
461 struct cmd_list_element
*
462 add_show_from_set (struct cmd_list_element
*setcmd
,
463 struct cmd_list_element
**list
)
466 const static char setstring
[] = "Set ";
468 /* Create a doc string by replacing "Set " at the start of the
469 `set'' command's doco with "Show ". */
470 gdb_assert (strncmp (setcmd
->doc
, setstring
, sizeof (setstring
) - 1) == 0);
471 doc
= concat ("Show ", setcmd
->doc
+ sizeof (setstring
) - 1, NULL
);
473 /* Insert the basic command. */
474 return add_set_or_show_cmd (setcmd
->name
, show_cmd
, setcmd
->class,
475 setcmd
->var_type
, setcmd
->var
, doc
, list
);
478 /* Remove the command named NAME from the command list. */
481 delete_cmd (char *name
, struct cmd_list_element
**list
)
483 register struct cmd_list_element
*c
;
484 struct cmd_list_element
*p
;
486 while (*list
&& STREQ ((*list
)->name
, name
))
488 if ((*list
)->hookee_pre
)
489 (*list
)->hookee_pre
->hook_pre
= 0; /* Hook slips out of its mouth */
490 if ((*list
)->hookee_post
)
491 (*list
)->hookee_post
->hook_post
= 0; /* Hook slips out of its bottom */
498 for (c
= *list
; c
->next
;)
500 if (STREQ (c
->next
->name
, name
))
502 if (c
->next
->hookee_pre
)
503 c
->next
->hookee_pre
->hook_pre
= 0; /* hooked cmd gets away. */
504 if (c
->next
->hookee_post
)
505 c
->next
->hookee_post
->hook_post
= 0; /* remove post hook */
506 /* :( no fishing metaphore */
516 /* Shorthands to the commands above. */
518 /* Add an element to the list of info subcommands. */
520 struct cmd_list_element
*
521 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
523 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
526 /* Add an alias to the list of info subcommands. */
528 struct cmd_list_element
*
529 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
531 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
534 /* Add an element to the list of commands. */
536 struct cmd_list_element
*
537 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
540 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
543 /* Add an alias or abbreviation command to the list of commands. */
545 struct cmd_list_element
*
546 add_com_alias (char *name
, char *oldname
, enum command_class
class,
549 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
552 /* Recursively walk the commandlist structures, and print out the
553 documentation of commands that match our regex in either their
554 name, or their documentation.
557 apropos_cmd (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
558 struct re_pattern_buffer
*regex
, char *prefix
)
560 register struct cmd_list_element
*c
;
561 int returnvalue
=1; /*Needed to avoid double printing*/
562 /* Walk through the commands */
563 for (c
=commandlist
;c
;c
=c
->next
)
567 /* Try to match against the name*/
568 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
569 if (returnvalue
>= 0)
571 /* Stolen from help_cmd_list. We don't directly use
572 * help_cmd_list because it doesn't let us print out
575 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
576 print_doc_line (stream
, c
->doc
);
577 fputs_filtered ("\n", stream
);
578 returnvalue
=0; /*Set this so we don't print it again.*/
581 if (c
->doc
!= NULL
&& returnvalue
!= 0)
583 /* Try to match against documentation */
584 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
586 /* Stolen from help_cmd_list. We don't directly use
587 * help_cmd_list because it doesn't let us print out
590 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
591 print_doc_line (stream
, c
->doc
);
592 fputs_filtered ("\n", stream
);
595 /* Check if this command has subcommands */
596 if (c
->prefixlist
!= NULL
)
598 /* Recursively call ourselves on the subcommand list,
599 passing the right prefix in.
601 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
606 /* This command really has to deal with two things:
607 * 1) I want documentation on *this string* (usually called by
608 * "help commandname").
609 * 2) I want documentation on *this list* (usually called by
610 * giving a command that requires subcommands. Also called by saying
613 * I am going to split this into two seperate comamnds, help_cmd and
618 help_cmd (char *command
, struct ui_file
*stream
)
620 struct cmd_list_element
*c
;
621 extern struct cmd_list_element
*cmdlist
;
625 help_list (cmdlist
, "", all_classes
, stream
);
629 if (strcmp (command
, "all") == 0)
635 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
640 /* There are three cases here.
641 If c->prefixlist is nonzero, we have a prefix command.
642 Print its documentation, then list its subcommands.
644 If c->func is non NULL, we really have a command. Print its
645 documentation and return.
647 If c->func is NULL, we have a class name. Print its
648 documentation (as if it were a command) and then set class to the
649 number of this class so that the commands in the class will be
652 fputs_filtered (c
->doc
, stream
);
653 fputs_filtered ("\n", stream
);
655 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
657 fprintf_filtered (stream
, "\n");
659 /* If this is a prefix command, print it's subcommands */
661 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
663 /* If this is a class name, print all of the commands in the class */
665 help_list (cmdlist
, "", c
->class, stream
);
667 if (c
->hook_pre
|| c
->hook_post
)
668 fprintf_filtered (stream
,
669 "\nThis command has a hook (or hooks) defined:\n");
672 fprintf_filtered (stream
,
673 "\tThis command is run after : %s (pre hook)\n",
676 fprintf_filtered (stream
,
677 "\tThis command is run before : %s (post hook)\n",
682 * Get a specific kind of help on a command list.
685 * CMDTYPE is the prefix to use in the title string.
686 * CLASS is the class with which to list the nodes of this list (see
687 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
688 * everything, ALL_CLASSES for just classes, and non-negative for only things
689 * in a specific class.
690 * and STREAM is the output stream on which to print things.
691 * If you call this routine with a class >= 0, it recurses.
694 help_list (struct cmd_list_element
*list
, char *cmdtype
,
695 enum command_class
class, struct ui_file
*stream
)
698 char *cmdtype1
, *cmdtype2
;
700 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
701 len
= strlen (cmdtype
);
702 cmdtype1
= (char *) alloca (len
+ 1);
704 cmdtype2
= (char *) alloca (len
+ 4);
709 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
711 strncpy (cmdtype2
, cmdtype
, len
- 1);
712 strcpy (cmdtype2
+ len
- 1, " sub");
715 if (class == all_classes
)
716 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
718 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
720 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
722 if (class == all_classes
)
724 fprintf_filtered (stream
, "\n\
725 Type \"help%s\" followed by a class name for a list of commands in ",
728 fprintf_filtered (stream
, "that class.");
731 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
734 fputs_filtered ("for ", stream
);
736 fputs_filtered ("full ", stream
);
738 fputs_filtered ("documentation.\n", stream
);
739 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
744 help_all (struct ui_file
*stream
)
746 struct cmd_list_element
*c
;
747 extern struct cmd_list_element
*cmdlist
;
749 for (c
= cmdlist
; c
; c
= c
->next
)
753 /* If this is a prefix command, print it's subcommands */
755 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 0, stream
);
757 /* If this is a class name, print all of the commands in the class */
758 else if (c
->func
== NULL
)
759 help_cmd_list (cmdlist
, c
->class, "", 0, stream
);
763 /* Print only the first line of STR on STREAM. */
765 print_doc_line (struct ui_file
*stream
, char *str
)
767 static char *line_buffer
= 0;
768 static int line_size
;
774 line_buffer
= (char *) xmalloc (line_size
);
778 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
780 if (p
- str
> line_size
- 1)
782 line_size
= p
- str
+ 1;
784 line_buffer
= (char *) xmalloc (line_size
);
786 strncpy (line_buffer
, str
, p
- str
);
787 line_buffer
[p
- str
] = '\0';
788 if (islower (line_buffer
[0]))
789 line_buffer
[0] = toupper (line_buffer
[0]);
790 ui_out_text (uiout
, line_buffer
);
794 * Implement a help command on command list LIST.
795 * RECURSE should be non-zero if this should be done recursively on
796 * all sublists of LIST.
797 * PREFIX is the prefix to print before each command name.
798 * STREAM is the stream upon which the output should be written.
800 * A non-negative class number to list only commands in that
802 * ALL_COMMANDS to list all commands in list.
803 * ALL_CLASSES to list all classes in list.
805 * Note that RECURSE will be active on *all* sublists, not just the
806 * ones selected by the criteria above (ie. the selection mechanism
807 * is at the low level, not the high-level).
810 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
811 char *prefix
, int recurse
, struct ui_file
*stream
)
813 register struct cmd_list_element
*c
;
815 for (c
= list
; c
; c
= c
->next
)
817 if (c
->abbrev_flag
== 0 &&
818 (class == all_commands
819 || (class == all_classes
&& c
->func
== NULL
)
820 || (class == c
->class && c
->func
!= NULL
)))
822 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
823 print_doc_line (stream
, c
->doc
);
824 fputs_filtered ("\n", stream
);
827 && c
->prefixlist
!= 0
828 && c
->abbrev_flag
== 0)
829 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
, 1, stream
);
834 /* Search the input clist for 'command'. Return the command if
835 found (or NULL if not), and return the number of commands
838 static struct cmd_list_element
*
839 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
840 int ignore_help_classes
, int *nfound
)
842 struct cmd_list_element
*found
, *c
;
844 found
= (struct cmd_list_element
*) NULL
;
846 for (c
= clist
; c
; c
= c
->next
)
847 if (!strncmp (command
, c
->name
, len
)
848 && (!ignore_help_classes
|| c
->func
))
852 if (c
->name
[len
] == '\0')
861 /* This routine takes a line of TEXT and a CLIST in which to start the
862 lookup. When it returns it will have incremented the text pointer past
863 the section of text it matched, set *RESULT_LIST to point to the list in
864 which the last word was matched, and will return a pointer to the cmd
865 list element which the text matches. It will return NULL if no match at
866 all was possible. It will return -1 (cast appropriately, ick) if ambigous
867 matches are possible; in this case *RESULT_LIST will be set to point to
868 the list in which there are ambiguous choices (and *TEXT will be set to
869 the ambiguous text string).
871 If the located command was an abbreviation, this routine returns the base
872 command of the abbreviation.
874 It does no error reporting whatsoever; control will always return
875 to the superior routine.
877 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
878 at the prefix_command (ie. the best match) *or* (special case) will be NULL
879 if no prefix command was ever found. For example, in the case of "info a",
880 "info" matches without ambiguity, but "a" could be "args" or "address", so
881 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
882 RESULT_LIST should not be interpeted as a pointer to the beginning of a
883 list; it simply points to a specific command. In the case of an ambiguous
884 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
885 "info t" can be "info types" or "info target"; upon return *TEXT has been
886 advanced past "info ").
888 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
889 affect the operation).
891 This routine does *not* modify the text pointed to by TEXT.
893 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
894 are actually help classes rather than commands (i.e. the function field of
895 the struct cmd_list_element is NULL). */
897 struct cmd_list_element
*
898 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
899 struct cmd_list_element
**result_list
, int ignore_help_classes
)
902 int len
, tmp
, nfound
;
903 struct cmd_list_element
*found
, *c
;
906 while (**text
== ' ' || **text
== '\t')
909 /* Treating underscores as part of command words is important
910 so that "set args_foo()" doesn't get interpreted as
911 "set args _foo()". */
912 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
915 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
918 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
920 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
924 /* If nothing but whitespace, return 0. */
930 /* *text and p now bracket the first command word to lookup (and
931 it's length is len). We copy this into a local temporary */
934 command
= (char *) alloca (len
+ 1);
935 for (tmp
= 0; tmp
< len
; tmp
++)
937 char x
= (*text
)[tmp
];
945 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
948 ** We didn't find the command in the entered case, so lower case it
951 if (!found
|| nfound
== 0)
953 for (tmp
= 0; tmp
< len
; tmp
++)
955 char x
= command
[tmp
];
956 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
958 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
961 /* If nothing matches, we have a simple failure. */
967 if (result_list
!= NULL
)
968 /* Will be modified in calling routine
969 if we know what the prefix command is. */
971 return (struct cmd_list_element
*) -1; /* Ambiguous. */
974 /* We've matched something on this list. Move text pointer forward. */
978 if (found
->cmd_pointer
)
980 /* We drop the alias (abbreviation) in favor of the command it is
981 pointing to. If the alias is deprecated, though, we need to
982 warn the user about it before we drop it. Note that while we
983 are warning about the alias, we may also warn about the command
984 itself and we will adjust the appropriate DEPRECATED_WARN_USER
987 if (found
->flags
& DEPRECATED_WARN_USER
)
988 deprecated_cmd_warning (&line
);
989 found
= found
->cmd_pointer
;
991 /* If we found a prefix command, keep looking. */
993 if (found
->prefixlist
)
995 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
996 ignore_help_classes
);
999 /* Didn't find anything; this is as far as we got. */
1000 if (result_list
!= NULL
)
1001 *result_list
= clist
;
1004 else if (c
== (struct cmd_list_element
*) -1)
1006 /* We've gotten this far properly, but the next step
1007 is ambiguous. We need to set the result list to the best
1008 we've found (if an inferior hasn't already set it). */
1009 if (result_list
!= NULL
)
1011 /* This used to say *result_list = *found->prefixlist
1012 If that was correct, need to modify the documentation
1013 at the top of this function to clarify what is supposed
1015 *result_list
= found
;
1026 if (result_list
!= NULL
)
1027 *result_list
= clist
;
1032 /* All this hair to move the space to the front of cmdtype */
1035 undef_cmd_error (char *cmdtype
, char *q
)
1037 error ("Undefined %scommand: \"%s\". Try \"help%s%.*s\".",
1040 *cmdtype
? " " : "",
1041 (int) strlen (cmdtype
) - 1,
1045 /* Look up the contents of *LINE as a command in the command list LIST.
1046 LIST is a chain of struct cmd_list_element's.
1047 If it is found, return the struct cmd_list_element for that command
1048 and update *LINE to point after the command name, at the first argument.
1049 If not found, call error if ALLOW_UNKNOWN is zero
1050 otherwise (or if error returns) return zero.
1051 Call error if specified command is ambiguous,
1052 unless ALLOW_UNKNOWN is negative.
1053 CMDTYPE precedes the word "command" in the error message.
1055 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1056 elements which are actually help classes rather than commands (i.e.
1057 the function field of the struct cmd_list_element is 0). */
1059 struct cmd_list_element
*
1060 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1061 int allow_unknown
, int ignore_help_classes
)
1063 struct cmd_list_element
*last_list
= 0;
1064 struct cmd_list_element
*c
=
1065 lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1067 /* Note: Do not remove trailing whitespace here because this
1068 would be wrong for complete_command. Jim Kingdon */
1075 error ("Lack of needed %scommand", cmdtype
);
1078 char *p
= *line
, *q
;
1080 while (isalnum (*p
) || *p
== '-')
1083 q
= (char *) alloca (p
- *line
+ 1);
1084 strncpy (q
, *line
, p
- *line
);
1085 q
[p
- *line
] = '\0';
1086 undef_cmd_error (cmdtype
, q
);
1092 else if (c
== (struct cmd_list_element
*) -1)
1094 /* Ambigous. Local values should be off prefixlist or called
1096 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1098 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1099 struct cmd_list_element
*local_list
=
1100 (last_list
? *(last_list
->prefixlist
) : list
);
1102 if (local_allow_unknown
< 0)
1105 return last_list
; /* Found something. */
1107 return 0; /* Found nothing. */
1111 /* Report as error. */
1116 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1117 && (*line
)[amb_len
] != '\t');
1122 for (c
= local_list
; c
; c
= c
->next
)
1123 if (!strncmp (*line
, c
->name
, amb_len
))
1125 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1127 if (strlen (ambbuf
))
1128 strcat (ambbuf
, ", ");
1129 strcat (ambbuf
, c
->name
);
1133 strcat (ambbuf
, "..");
1137 error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype
,
1139 return 0; /* lint */
1144 /* We've got something. It may still not be what the caller
1145 wants (if this command *needs* a subcommand). */
1146 while (**line
== ' ' || **line
== '\t')
1149 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1150 undef_cmd_error (c
->prefixname
, *line
);
1152 /* Seems to be what he wants. Return it. */
1158 /* We are here presumably because an alias or command in *TEXT is
1159 deprecated and a warning message should be generated. This function
1160 decodes *TEXT and potentially generates a warning message as outlined
1163 Example for 'set endian big' which has a fictitious alias 'seb'.
1165 If alias wasn't used in *TEXT, and the command is deprecated:
1166 "warning: 'set endian big' is deprecated."
1168 If alias was used, and only the alias is deprecated:
1169 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1171 If alias was used and command is deprecated (regardless of whether the
1172 alias itself is deprecated:
1174 "warning: 'set endian big' (seb) is deprecated."
1176 After the message has been sent, clear the appropriate flags in the
1177 command and/or the alias so the user is no longer bothered.
1181 deprecated_cmd_warning (char **text
)
1183 struct cmd_list_element
*alias
= NULL
;
1184 struct cmd_list_element
*prefix_cmd
= NULL
;
1185 struct cmd_list_element
*cmd
= NULL
;
1186 struct cmd_list_element
*c
;
1189 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1190 /* return if text doesn't evaluate to a command */
1193 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1194 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1195 /* return if nothing is deprecated */
1198 printf_filtered ("Warning:");
1200 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1201 printf_filtered (" '%s', an alias for the", alias
->name
);
1203 printf_filtered (" command '");
1206 printf_filtered ("%s", prefix_cmd
->prefixname
);
1208 printf_filtered ("%s", cmd
->name
);
1210 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1211 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1213 printf_filtered ("' is deprecated.\n");
1216 /* if it is only the alias that is deprecated, we want to indicate the
1217 new alias, otherwise we'll indicate the new command */
1219 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1221 if (alias
->replacement
)
1222 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1224 printf_filtered ("No alternative known.\n\n");
1228 if (cmd
->replacement
)
1229 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1231 printf_filtered ("No alternative known.\n\n");
1234 /* We've warned you, now we'll keep quiet */
1236 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1238 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1243 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1244 Return 1 on success, 0 on failure.
1246 If LINE refers to an alias, *alias will point to that alias.
1248 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1249 command) set *prefix_cmd.
1251 Set *cmd to point to the command LINE indicates.
1253 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1254 exist, they are NULL when we return.
1258 lookup_cmd_composition (char *text
,
1259 struct cmd_list_element
**alias
,
1260 struct cmd_list_element
**prefix_cmd
,
1261 struct cmd_list_element
**cmd
)
1264 int len
, tmp
, nfound
;
1265 struct cmd_list_element
*cur_list
;
1266 struct cmd_list_element
*prev_cmd
;
1275 /* Go through as many command lists as we need to
1276 to find the command TEXT refers to. */
1280 while (*text
== ' ' || *text
== '\t')
1283 /* Treating underscores as part of command words is important
1284 so that "set args_foo()" doesn't get interpreted as
1285 "set args _foo()". */
1286 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1289 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1292 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1294 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1298 /* If nothing but whitespace, return. */
1304 /* text and p now bracket the first command word to lookup (and
1305 it's length is len). We copy this into a local temporary */
1307 command
= (char *) alloca (len
+ 1);
1308 for (tmp
= 0; tmp
< len
; tmp
++)
1313 command
[len
] = '\0';
1318 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1320 /* We didn't find the command in the entered case, so lower case it
1323 if (!*cmd
|| nfound
== 0)
1325 for (tmp
= 0; tmp
< len
; tmp
++)
1327 char x
= command
[tmp
];
1328 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1330 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1333 if (*cmd
== (struct cmd_list_element
*) -1)
1335 return 0; /* ambiguous */
1339 return 0; /* nothing found */
1342 if ((*cmd
)->cmd_pointer
)
1344 /* cmd was actually an alias, we note that an alias was used
1345 (by assigning *alais) and we set *cmd.
1348 *cmd
= (*cmd
)->cmd_pointer
;
1350 *prefix_cmd
= prev_cmd
;
1352 if ((*cmd
)->prefixlist
)
1353 cur_list
= *(*cmd
)->prefixlist
;
1361 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1363 /* Return a vector of char pointers which point to the different
1364 possible completions in LIST of TEXT.
1366 WORD points in the same buffer as TEXT, and completions should be
1367 returned relative to this position. For example, suppose TEXT is "foo"
1368 and we want to complete to "foobar". If WORD is "oo", return
1369 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1372 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1374 struct cmd_list_element
*ptr
;
1376 int sizeof_matchlist
;
1378 int textlen
= strlen (text
);
1380 sizeof_matchlist
= 10;
1381 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1384 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1385 if (!strncmp (ptr
->name
, text
, textlen
)
1386 && !ptr
->abbrev_flag
1388 || ptr
->prefixlist
))
1390 if (matches
== sizeof_matchlist
)
1392 sizeof_matchlist
*= 2;
1393 matchlist
= (char **) xrealloc ((char *) matchlist
,
1395 * sizeof (char *)));
1398 matchlist
[matches
] = (char *)
1399 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1401 strcpy (matchlist
[matches
], ptr
->name
);
1402 else if (word
> text
)
1404 /* Return some portion of ptr->name. */
1405 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1409 /* Return some of text plus ptr->name. */
1410 strncpy (matchlist
[matches
], word
, text
- word
);
1411 matchlist
[matches
][text
- word
] = '\0';
1412 strcat (matchlist
[matches
], ptr
->name
);
1424 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1425 * sizeof (char *)));
1426 matchlist
[matches
] = (char *) 0;
1432 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1434 /* Return a vector of char pointers which point to the different
1435 possible completions in CMD of TEXT.
1437 WORD points in the same buffer as TEXT, and completions should be
1438 returned relative to this position. For example, suppose TEXT is "foo"
1439 and we want to complete to "foobar". If WORD is "oo", return
1440 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1443 complete_on_enum (const char *enumlist
[],
1448 int sizeof_matchlist
;
1450 int textlen
= strlen (text
);
1454 sizeof_matchlist
= 10;
1455 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1458 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1459 if (strncmp (name
, text
, textlen
) == 0)
1461 if (matches
== sizeof_matchlist
)
1463 sizeof_matchlist
*= 2;
1464 matchlist
= (char **) xrealloc ((char *) matchlist
,
1466 * sizeof (char *)));
1469 matchlist
[matches
] = (char *)
1470 xmalloc (strlen (word
) + strlen (name
) + 1);
1472 strcpy (matchlist
[matches
], name
);
1473 else if (word
> text
)
1475 /* Return some portion of name. */
1476 strcpy (matchlist
[matches
], name
+ (word
- text
));
1480 /* Return some of text plus name. */
1481 strncpy (matchlist
[matches
], word
, text
- word
);
1482 matchlist
[matches
][text
- word
] = '\0';
1483 strcat (matchlist
[matches
], name
);
1495 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1496 * sizeof (char *)));
1497 matchlist
[matches
] = (char *) 0;
1504 /* check function pointer */
1506 cmd_func_p (struct cmd_list_element
*cmd
)
1508 return (cmd
->func
!= NULL
);
1512 /* call the command function */
1514 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1516 if (cmd_func_p (cmd
))
1517 (*cmd
->func
) (cmd
, args
, from_tty
);
1519 error ("Invalid command");