1 /* Handle lists of commands, their decoding and documentation, for GDB.
3 Copyright (c) 1986-2013 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_regex.h"
22 #include "gdb_string.h"
23 #include "completer.h"
26 #include "cli/cli-cmds.h"
27 #include "cli/cli-decode.h"
30 #include "tui/tui.h" /* For tui_active et al. */
33 #include "gdb_assert.h"
35 /* Prototypes for local functions. */
37 static void undef_cmd_error (char *, char *);
39 static struct cmd_list_element
*delete_cmd (char *name
,
40 struct cmd_list_element
**list
,
41 struct cmd_list_element
**prehook
,
42 struct cmd_list_element
**prehookee
,
43 struct cmd_list_element
**posthook
,
44 struct cmd_list_element
**posthookee
);
46 static struct cmd_list_element
*find_cmd (char *command
,
48 struct cmd_list_element
*clist
,
49 int ignore_help_classes
,
52 static void help_all (struct ui_file
*stream
);
54 /* Look up a command whose 'prefixlist' is KEY. Return the command if found,
55 otherwise return NULL. */
57 static struct cmd_list_element
*
58 lookup_cmd_for_prefixlist (struct cmd_list_element
**key
,
59 struct cmd_list_element
*list
)
61 struct cmd_list_element
*p
= NULL
;
63 for (p
= list
; p
!= NULL
; p
= p
->next
)
65 struct cmd_list_element
*q
;
67 if (p
->prefixlist
== NULL
)
69 else if (p
->prefixlist
== key
)
72 q
= lookup_cmd_for_prefixlist (key
, *(p
->prefixlist
));
81 set_cmd_prefix (struct cmd_list_element
*c
, struct cmd_list_element
**list
)
83 struct cmd_list_element
*p
;
85 /* Check to see if *LIST contains any element other than C. */
86 for (p
= *list
; p
!= NULL
; p
= p
->next
)
92 /* *SET_LIST only contains SET. */
93 p
= lookup_cmd_for_prefixlist (list
, setlist
);
95 c
->prefix
= p
? (p
->cmd_pointer
? p
->cmd_pointer
: p
) : p
;
98 c
->prefix
= p
->prefix
;
102 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
103 struct ui_file
*stream
);
106 /* Set the callback function for the specified command. For each both
107 the commands callback and func() are set. The latter set to a
108 bounce function (unless cfunc / sfunc is NULL that is). */
111 do_cfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
113 c
->function
.cfunc (args
, from_tty
); /* Ok. */
117 set_cmd_cfunc (struct cmd_list_element
*cmd
, cmd_cfunc_ftype
*cfunc
)
122 cmd
->func
= do_cfunc
;
123 cmd
->function
.cfunc
= cfunc
; /* Ok. */
127 do_sfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
129 c
->function
.sfunc (args
, from_tty
, c
); /* Ok. */
133 set_cmd_sfunc (struct cmd_list_element
*cmd
, cmd_sfunc_ftype
*sfunc
)
138 cmd
->func
= do_sfunc
;
139 cmd
->function
.sfunc
= sfunc
; /* Ok. */
143 cmd_cfunc_eq (struct cmd_list_element
*cmd
,
144 void (*cfunc
) (char *args
, int from_tty
))
146 return cmd
->func
== do_cfunc
&& cmd
->function
.cfunc
== cfunc
;
150 set_cmd_context (struct cmd_list_element
*cmd
, void *context
)
152 cmd
->context
= context
;
156 get_cmd_context (struct cmd_list_element
*cmd
)
162 cmd_type (struct cmd_list_element
*cmd
)
168 set_cmd_completer (struct cmd_list_element
*cmd
, completer_ftype
*completer
)
170 cmd
->completer
= completer
; /* Ok. */
173 /* Add element named NAME.
174 Space for NAME and DOC must be allocated by the caller.
175 CLASS is the top level category into which commands are broken down
177 FUN should be the function to execute the command;
178 it will get a character string as argument, with leading
179 and trailing blanks already eliminated.
181 DOC is a documentation string for the command.
182 Its first line should be a complete sentence.
183 It should start with ? for a command that is an abbreviation
184 or with * for a command that most users don't need to know about.
186 Add this command to command list *LIST.
188 Returns a pointer to the added command (not necessarily the head
191 struct cmd_list_element
*
192 add_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
193 char *doc
, struct cmd_list_element
**list
)
195 struct cmd_list_element
*c
196 = (struct cmd_list_element
*) xmalloc (sizeof (struct cmd_list_element
));
197 struct cmd_list_element
*p
, *iter
;
199 /* Turn each alias of the old command into an alias of the new
201 c
->aliases
= delete_cmd (name
, list
, &c
->hook_pre
, &c
->hookee_pre
,
202 &c
->hook_post
, &c
->hookee_post
);
203 for (iter
= c
->aliases
; iter
; iter
= iter
->alias_chain
)
204 iter
->cmd_pointer
= c
;
206 c
->hook_pre
->hookee_pre
= c
;
208 c
->hookee_pre
->hook_pre
= c
;
210 c
->hook_post
->hookee_post
= c
;
212 c
->hookee_post
->hook_post
= c
;
214 if (*list
== NULL
|| strcmp ((*list
)->name
, name
) >= 0)
222 while (p
->next
&& strcmp (p
->next
->name
, name
) <= 0)
232 set_cmd_cfunc (c
, fun
);
233 set_cmd_context (c
, NULL
);
236 c
->replacement
= NULL
;
237 c
->pre_show_hook
= NULL
;
239 c
->prefixlist
= NULL
;
240 c
->prefixname
= NULL
;
241 c
->allow_unknown
= 0;
244 set_cmd_completer (c
, make_symbol_completion_list_fn
);
246 c
->type
= not_set_cmd
;
248 c
->var_type
= var_boolean
;
250 c
->user_commands
= NULL
;
251 c
->cmd_pointer
= NULL
;
252 c
->alias_chain
= NULL
;
257 /* Deprecates a command CMD.
258 REPLACEMENT is the name of the command which should be used in
259 place of this command, or NULL if no such command exists.
261 This function does not check to see if command REPLACEMENT exists
262 since gdb may not have gotten around to adding REPLACEMENT when
263 this function is called.
265 Returns a pointer to the deprecated command. */
267 struct cmd_list_element
*
268 deprecate_cmd (struct cmd_list_element
*cmd
, char *replacement
)
270 cmd
->flags
|= (CMD_DEPRECATED
| DEPRECATED_WARN_USER
);
272 if (replacement
!= NULL
)
273 cmd
->replacement
= replacement
;
275 cmd
->replacement
= NULL
;
280 struct cmd_list_element
*
281 add_alias_cmd (char *name
, char *oldname
, enum command_class
class,
282 int abbrev_flag
, struct cmd_list_element
**list
)
284 /* Must do this since lookup_cmd tries to side-effect its first
287 struct cmd_list_element
*old
;
288 struct cmd_list_element
*c
;
290 copied_name
= (char *) alloca (strlen (oldname
) + 1);
291 strcpy (copied_name
, oldname
);
292 old
= lookup_cmd (&copied_name
, *list
, "", 1, 1);
296 struct cmd_list_element
*prehook
, *prehookee
, *posthook
, *posthookee
;
297 struct cmd_list_element
*aliases
= delete_cmd (name
, list
,
298 &prehook
, &prehookee
,
299 &posthook
, &posthookee
);
301 /* If this happens, it means a programmer error somewhere. */
302 gdb_assert (!aliases
&& !prehook
&& !prehookee
303 && !posthook
&& ! posthookee
);
307 c
= add_cmd (name
, class, NULL
, old
->doc
, list
);
309 /* If OLD->DOC can be freed, we should make another copy. */
310 if ((old
->flags
& DOC_ALLOCATED
) != 0)
312 c
->doc
= xstrdup (old
->doc
);
313 c
->flags
|= DOC_ALLOCATED
;
315 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
317 c
->function
= old
->function
;
318 c
->prefixlist
= old
->prefixlist
;
319 c
->prefixname
= old
->prefixname
;
320 c
->allow_unknown
= old
->allow_unknown
;
321 c
->abbrev_flag
= abbrev_flag
;
322 c
->cmd_pointer
= old
;
323 c
->alias_chain
= old
->aliases
;
326 set_cmd_prefix (c
, list
);
330 /* Like add_cmd but adds an element for a command prefix: a name that
331 should be followed by a subcommand to be looked up in another
332 command list. PREFIXLIST should be the address of the variable
333 containing that list. */
335 struct cmd_list_element
*
336 add_prefix_cmd (char *name
, enum command_class
class,
337 void (*fun
) (char *, int),
338 char *doc
, struct cmd_list_element
**prefixlist
,
339 char *prefixname
, int allow_unknown
,
340 struct cmd_list_element
**list
)
342 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
343 struct cmd_list_element
*p
;
345 c
->prefixlist
= prefixlist
;
346 c
->prefixname
= prefixname
;
347 c
->allow_unknown
= allow_unknown
;
349 if (list
== &cmdlist
)
352 set_cmd_prefix (c
, list
);
354 /* Update the field 'prefix' of each cmd_list_element in *PREFIXLIST. */
355 for (p
= *prefixlist
; p
!= NULL
; p
= p
->next
)
361 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
363 struct cmd_list_element
*
364 add_abbrev_prefix_cmd (char *name
, enum command_class
class,
365 void (*fun
) (char *, int), char *doc
,
366 struct cmd_list_element
**prefixlist
, char *prefixname
,
367 int allow_unknown
, struct cmd_list_element
**list
)
369 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
371 c
->prefixlist
= prefixlist
;
372 c
->prefixname
= prefixname
;
373 c
->allow_unknown
= allow_unknown
;
378 /* This is an empty "cfunc". */
380 not_just_help_class_command (char *args
, int from_tty
)
384 /* This is an empty "sfunc". */
385 static void empty_sfunc (char *, int, struct cmd_list_element
*);
388 empty_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
392 /* Add element named NAME to command list LIST (the list for set/show
393 or some sublist thereof).
394 TYPE is set_cmd or show_cmd.
395 CLASS is as in add_cmd.
396 VAR_TYPE is the kind of thing we are setting.
397 VAR is address of the variable being controlled by this command.
398 DOC is the documentation string. */
400 static struct cmd_list_element
*
401 add_set_or_show_cmd (char *name
,
403 enum command_class
class,
407 struct cmd_list_element
**list
)
409 struct cmd_list_element
*c
= add_cmd (name
, class, NULL
, doc
, list
);
411 gdb_assert (type
== set_cmd
|| type
== show_cmd
);
413 c
->var_type
= var_type
;
415 /* This needs to be something besides NULL so that this isn't
416 treated as a help class. */
417 set_cmd_sfunc (c
, empty_sfunc
);
421 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
422 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
423 setting. VAR is address of the variable being controlled by this
424 command. SET_FUNC and SHOW_FUNC are the callback functions (if
425 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
426 strings. PRINT the format string to print the value. SET_RESULT
427 and SHOW_RESULT, if not NULL, are set to the resulting command
431 add_setshow_cmd_full (char *name
,
432 enum command_class
class,
433 var_types var_type
, void *var
,
434 const char *set_doc
, const char *show_doc
,
435 const char *help_doc
,
436 cmd_sfunc_ftype
*set_func
,
437 show_value_ftype
*show_func
,
438 struct cmd_list_element
**set_list
,
439 struct cmd_list_element
**show_list
,
440 struct cmd_list_element
**set_result
,
441 struct cmd_list_element
**show_result
)
443 struct cmd_list_element
*set
;
444 struct cmd_list_element
*show
;
448 if (help_doc
!= NULL
)
450 full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
451 full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
455 full_set_doc
= xstrdup (set_doc
);
456 full_show_doc
= xstrdup (show_doc
);
458 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
459 full_set_doc
, set_list
);
460 set
->flags
|= DOC_ALLOCATED
;
462 if (set_func
!= NULL
)
463 set_cmd_sfunc (set
, set_func
);
465 set_cmd_prefix (set
, set_list
);
467 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
468 full_show_doc
, show_list
);
469 show
->flags
|= DOC_ALLOCATED
;
470 show
->show_value_func
= show_func
;
472 if (set_result
!= NULL
)
474 if (show_result
!= NULL
)
478 /* Add element named NAME to command list LIST (the list for set or
479 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
480 of strings which may follow NAME. VAR is address of the variable
481 which will contain the matching string (from ENUMLIST). */
484 add_setshow_enum_cmd (char *name
,
485 enum command_class
class,
486 const char *const *enumlist
,
489 const char *show_doc
,
490 const char *help_doc
,
491 cmd_sfunc_ftype
*set_func
,
492 show_value_ftype
*show_func
,
493 struct cmd_list_element
**set_list
,
494 struct cmd_list_element
**show_list
)
496 struct cmd_list_element
*c
;
498 add_setshow_cmd_full (name
, class, var_enum
, var
,
499 set_doc
, show_doc
, help_doc
,
506 const char * const auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
508 /* Add an auto-boolean command named NAME to both the set and show
509 command list lists. CLASS is as in add_cmd. VAR is address of the
510 variable which will contain the value. DOC is the documentation
511 string. FUNC is the corresponding callback. */
513 add_setshow_auto_boolean_cmd (char *name
,
514 enum command_class
class,
515 enum auto_boolean
*var
,
516 const char *set_doc
, const char *show_doc
,
517 const char *help_doc
,
518 cmd_sfunc_ftype
*set_func
,
519 show_value_ftype
*show_func
,
520 struct cmd_list_element
**set_list
,
521 struct cmd_list_element
**show_list
)
523 struct cmd_list_element
*c
;
525 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
526 set_doc
, show_doc
, help_doc
,
530 c
->enums
= auto_boolean_enums
;
533 /* Add element named NAME to both the set and show command LISTs (the
534 list for set/show or some sublist thereof). CLASS is as in
535 add_cmd. VAR is address of the variable which will contain the
536 value. SET_DOC and SHOW_DOC are the documentation strings. */
538 add_setshow_boolean_cmd (char *name
, enum command_class
class, int *var
,
539 const char *set_doc
, const char *show_doc
,
540 const char *help_doc
,
541 cmd_sfunc_ftype
*set_func
,
542 show_value_ftype
*show_func
,
543 struct cmd_list_element
**set_list
,
544 struct cmd_list_element
**show_list
)
546 static const char *boolean_enums
[] = { "on", "off", NULL
};
547 struct cmd_list_element
*c
;
549 add_setshow_cmd_full (name
, class, var_boolean
, var
,
550 set_doc
, show_doc
, help_doc
,
554 c
->enums
= boolean_enums
;
557 /* Add element named NAME to both the set and show command LISTs (the
558 list for set/show or some sublist thereof). */
560 add_setshow_filename_cmd (char *name
, enum command_class
class,
562 const char *set_doc
, const char *show_doc
,
563 const char *help_doc
,
564 cmd_sfunc_ftype
*set_func
,
565 show_value_ftype
*show_func
,
566 struct cmd_list_element
**set_list
,
567 struct cmd_list_element
**show_list
)
569 struct cmd_list_element
*set_result
;
571 add_setshow_cmd_full (name
, class, var_filename
, var
,
572 set_doc
, show_doc
, help_doc
,
576 set_cmd_completer (set_result
, filename_completer
);
579 /* Add element named NAME to both the set and show command LISTs (the
580 list for set/show or some sublist thereof). */
582 add_setshow_string_cmd (char *name
, enum command_class
class,
584 const char *set_doc
, const char *show_doc
,
585 const char *help_doc
,
586 cmd_sfunc_ftype
*set_func
,
587 show_value_ftype
*show_func
,
588 struct cmd_list_element
**set_list
,
589 struct cmd_list_element
**show_list
)
591 add_setshow_cmd_full (name
, class, var_string
, var
,
592 set_doc
, show_doc
, help_doc
,
598 /* Add element named NAME to both the set and show command LISTs (the
599 list for set/show or some sublist thereof). */
600 struct cmd_list_element
*
601 add_setshow_string_noescape_cmd (char *name
, enum command_class
class,
603 const char *set_doc
, const char *show_doc
,
604 const char *help_doc
,
605 cmd_sfunc_ftype
*set_func
,
606 show_value_ftype
*show_func
,
607 struct cmd_list_element
**set_list
,
608 struct cmd_list_element
**show_list
)
610 struct cmd_list_element
*set_cmd
;
612 add_setshow_cmd_full (name
, class, var_string_noescape
, var
,
613 set_doc
, show_doc
, help_doc
,
620 /* Add element named NAME to both the set and show command LISTs (the
621 list for set/show or some sublist thereof). */
623 add_setshow_optional_filename_cmd (char *name
, enum command_class
class,
625 const char *set_doc
, const char *show_doc
,
626 const char *help_doc
,
627 cmd_sfunc_ftype
*set_func
,
628 show_value_ftype
*show_func
,
629 struct cmd_list_element
**set_list
,
630 struct cmd_list_element
**show_list
)
632 struct cmd_list_element
*set_result
;
634 add_setshow_cmd_full (name
, class, var_optional_filename
, var
,
635 set_doc
, show_doc
, help_doc
,
640 set_cmd_completer (set_result
, filename_completer
);
644 /* Add element named NAME to both the set and show command LISTs (the
645 list for set/show or some sublist thereof). CLASS is as in
646 add_cmd. VAR is address of the variable which will contain the
647 value. SET_DOC and SHOW_DOC are the documentation strings. This
648 function is only used in Python API. Please don't use it elsewhere. */
650 add_setshow_integer_cmd (char *name
, enum command_class
class,
652 const char *set_doc
, const char *show_doc
,
653 const char *help_doc
,
654 cmd_sfunc_ftype
*set_func
,
655 show_value_ftype
*show_func
,
656 struct cmd_list_element
**set_list
,
657 struct cmd_list_element
**show_list
)
659 add_setshow_cmd_full (name
, class, var_integer
, var
,
660 set_doc
, show_doc
, help_doc
,
666 /* Add element named NAME to both the set and show command LISTs (the
667 list for set/show or some sublist thereof). CLASS is as in
668 add_cmd. VAR is address of the variable which will contain the
669 value. SET_DOC and SHOW_DOC are the documentation strings. */
671 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
673 const char *set_doc
, const char *show_doc
,
674 const char *help_doc
,
675 cmd_sfunc_ftype
*set_func
,
676 show_value_ftype
*show_func
,
677 struct cmd_list_element
**set_list
,
678 struct cmd_list_element
**show_list
)
680 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
681 set_doc
, show_doc
, help_doc
,
687 /* Add element named NAME to both the set and show command LISTs (the
688 list for set/show or some sublist thereof). CLASS is as in
689 add_cmd. VAR is address of the variable which will contain the
690 value. SET_DOC and SHOW_DOC are the documentation strings. */
692 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
694 const char *set_doc
, const char *show_doc
,
695 const char *help_doc
,
696 cmd_sfunc_ftype
*set_func
,
697 show_value_ftype
*show_func
,
698 struct cmd_list_element
**set_list
,
699 struct cmd_list_element
**show_list
)
701 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
702 set_doc
, show_doc
, help_doc
,
709 add_setshow_zuinteger_unlimited_cmd (char *name
,
710 enum command_class
class,
713 const char *show_doc
,
714 const char *help_doc
,
715 cmd_sfunc_ftype
*set_func
,
716 show_value_ftype
*show_func
,
717 struct cmd_list_element
**set_list
,
718 struct cmd_list_element
**show_list
)
720 add_setshow_cmd_full (name
, class, var_zuinteger_unlimited
, var
,
721 set_doc
, show_doc
, help_doc
,
727 /* Add element named NAME to both the set and show command LISTs (the
728 list for set/show or some sublist thereof). CLASS is as in
729 add_cmd. VAR is address of the variable which will contain the
730 value. SET_DOC and SHOW_DOC are the documentation strings. */
732 add_setshow_zuinteger_cmd (char *name
, enum command_class
class,
734 const char *set_doc
, const char *show_doc
,
735 const char *help_doc
,
736 cmd_sfunc_ftype
*set_func
,
737 show_value_ftype
*show_func
,
738 struct cmd_list_element
**set_list
,
739 struct cmd_list_element
**show_list
)
741 add_setshow_cmd_full (name
, class, var_zuinteger
, var
,
742 set_doc
, show_doc
, help_doc
,
748 /* Remove the command named NAME from the command list. Return the
749 list commands which were aliased to the deleted command. If the
750 command had no aliases, return NULL. The various *HOOKs are set to
751 the pre- and post-hook commands for the deleted command. If the
752 command does not have a hook, the corresponding out parameter is
755 static struct cmd_list_element
*
756 delete_cmd (char *name
, struct cmd_list_element
**list
,
757 struct cmd_list_element
**prehook
,
758 struct cmd_list_element
**prehookee
,
759 struct cmd_list_element
**posthook
,
760 struct cmd_list_element
**posthookee
)
762 struct cmd_list_element
*iter
;
763 struct cmd_list_element
**previous_chain_ptr
;
764 struct cmd_list_element
*aliases
= NULL
;
770 previous_chain_ptr
= list
;
772 for (iter
= *previous_chain_ptr
; iter
; iter
= *previous_chain_ptr
)
774 if (strcmp (iter
->name
, name
) == 0)
777 iter
->destroyer (iter
, iter
->context
);
778 if (iter
->hookee_pre
)
779 iter
->hookee_pre
->hook_pre
= 0;
780 *prehook
= iter
->hook_pre
;
781 *prehookee
= iter
->hookee_pre
;
782 if (iter
->hookee_post
)
783 iter
->hookee_post
->hook_post
= 0;
784 if (iter
->doc
&& (iter
->flags
& DOC_ALLOCATED
) != 0)
786 *posthook
= iter
->hook_post
;
787 *posthookee
= iter
->hookee_post
;
789 /* Update the link. */
790 *previous_chain_ptr
= iter
->next
;
792 aliases
= iter
->aliases
;
794 /* If this command was an alias, remove it from the list of
796 if (iter
->cmd_pointer
)
798 struct cmd_list_element
**prevp
= &iter
->cmd_pointer
->aliases
;
799 struct cmd_list_element
*a
= *prevp
;
803 prevp
= &a
->alias_chain
;
806 *prevp
= iter
->alias_chain
;
811 /* We won't see another command with the same name. */
815 previous_chain_ptr
= &iter
->next
;
821 /* Shorthands to the commands above. */
823 /* Add an element to the list of info subcommands. */
825 struct cmd_list_element
*
826 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
828 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
831 /* Add an alias to the list of info subcommands. */
833 struct cmd_list_element
*
834 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
836 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
839 /* Add an element to the list of commands. */
841 struct cmd_list_element
*
842 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
845 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
848 /* Add an alias or abbreviation command to the list of commands. */
850 struct cmd_list_element
*
851 add_com_alias (char *name
, char *oldname
, enum command_class
class,
854 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
857 /* Recursively walk the commandlist structures, and print out the
858 documentation of commands that match our regex in either their
859 name, or their documentation.
862 apropos_cmd (struct ui_file
*stream
,
863 struct cmd_list_element
*commandlist
,
864 struct re_pattern_buffer
*regex
, char *prefix
)
866 struct cmd_list_element
*c
;
869 /* Walk through the commands. */
870 for (c
=commandlist
;c
;c
=c
->next
)
872 returnvalue
= -1; /* Needed to avoid double printing. */
875 /* Try to match against the name. */
876 returnvalue
= re_search (regex
, c
->name
, strlen(c
->name
),
877 0, strlen (c
->name
), NULL
);
878 if (returnvalue
>= 0)
880 print_help_for_command (c
, prefix
,
881 0 /* don't recurse */, stream
);
884 if (c
->doc
!= NULL
&& returnvalue
< 0)
886 /* Try to match against documentation. */
887 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
889 print_help_for_command (c
, prefix
,
890 0 /* don't recurse */, stream
);
893 /* Check if this command has subcommands and is not an
894 abbreviation. We skip listing subcommands of abbreviations
895 in order to avoid duplicates in the output. */
896 if (c
->prefixlist
!= NULL
&& !c
->abbrev_flag
)
898 /* Recursively call ourselves on the subcommand list,
899 passing the right prefix in. */
900 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
905 /* This command really has to deal with two things:
906 1) I want documentation on *this string* (usually called by
909 2) I want documentation on *this list* (usually called by giving a
910 command that requires subcommands. Also called by saying just
913 I am going to split this into two seperate comamnds, help_cmd and
917 help_cmd (char *command
, struct ui_file
*stream
)
919 struct cmd_list_element
*c
;
920 extern struct cmd_list_element
*cmdlist
;
924 help_list (cmdlist
, "", all_classes
, stream
);
928 if (strcmp (command
, "all") == 0)
934 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
939 /* There are three cases here.
940 If c->prefixlist is nonzero, we have a prefix command.
941 Print its documentation, then list its subcommands.
943 If c->func is non NULL, we really have a command. Print its
944 documentation and return.
946 If c->func is NULL, we have a class name. Print its
947 documentation (as if it were a command) and then set class to the
948 number of this class so that the commands in the class will be
951 fputs_filtered (c
->doc
, stream
);
952 fputs_filtered ("\n", stream
);
954 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
956 fprintf_filtered (stream
, "\n");
958 /* If this is a prefix command, print it's subcommands. */
960 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
962 /* If this is a class name, print all of the commands in the class. */
964 help_list (cmdlist
, "", c
->class, stream
);
966 if (c
->hook_pre
|| c
->hook_post
)
967 fprintf_filtered (stream
,
968 "\nThis command has a hook (or hooks) defined:\n");
971 fprintf_filtered (stream
,
972 "\tThis command is run after : %s (pre hook)\n",
975 fprintf_filtered (stream
,
976 "\tThis command is run before : %s (post hook)\n",
981 * Get a specific kind of help on a command list.
984 * CMDTYPE is the prefix to use in the title string.
985 * CLASS is the class with which to list the nodes of this list (see
986 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
987 * everything, ALL_CLASSES for just classes, and non-negative for only things
988 * in a specific class.
989 * and STREAM is the output stream on which to print things.
990 * If you call this routine with a class >= 0, it recurses.
993 help_list (struct cmd_list_element
*list
, char *cmdtype
,
994 enum command_class
class, struct ui_file
*stream
)
997 char *cmdtype1
, *cmdtype2
;
999 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
1001 len
= strlen (cmdtype
);
1002 cmdtype1
= (char *) alloca (len
+ 1);
1004 cmdtype2
= (char *) alloca (len
+ 4);
1009 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
1011 strncpy (cmdtype2
, cmdtype
, len
- 1);
1012 strcpy (cmdtype2
+ len
- 1, " sub");
1015 if (class == all_classes
)
1016 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
1018 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
1020 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
1022 if (class == all_classes
)
1024 fprintf_filtered (stream
, "\n\
1025 Type \"help%s\" followed by a class name for a list of commands in ",
1028 fprintf_filtered (stream
, "that class.");
1030 fprintf_filtered (stream
, "\n\
1031 Type \"help all\" for the list of all commands.");
1034 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
1035 cmdtype1
, cmdtype2
);
1037 fputs_filtered ("for ", stream
);
1039 fputs_filtered ("full ", stream
);
1041 fputs_filtered ("documentation.\n", stream
);
1042 fputs_filtered ("Type \"apropos word\" to search "
1043 "for commands related to \"word\".\n", stream
);
1044 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
1049 help_all (struct ui_file
*stream
)
1051 struct cmd_list_element
*c
;
1052 extern struct cmd_list_element
*cmdlist
;
1053 int seen_unclassified
= 0;
1055 for (c
= cmdlist
; c
; c
= c
->next
)
1059 /* If this is a class name, print all of the commands in the
1062 if (c
->func
== NULL
)
1064 fprintf_filtered (stream
, "\nCommand class: %s\n\n", c
->name
);
1065 help_cmd_list (cmdlist
, c
->class, "", 1, stream
);
1069 /* While it's expected that all commands are in some class,
1070 as a safety measure, we'll print commands outside of any
1071 class at the end. */
1073 for (c
= cmdlist
; c
; c
= c
->next
)
1078 if (c
->class == no_class
)
1080 if (!seen_unclassified
)
1082 fprintf_filtered (stream
, "\nUnclassified commands\n\n");
1083 seen_unclassified
= 1;
1085 print_help_for_command (c
, "", 1, stream
);
1091 /* Print only the first line of STR on STREAM. */
1093 print_doc_line (struct ui_file
*stream
, char *str
)
1095 static char *line_buffer
= 0;
1096 static int line_size
;
1102 line_buffer
= (char *) xmalloc (line_size
);
1105 /* Keep printing '.' or ',' not followed by a whitespace for embedded strings
1108 while (*p
&& *p
!= '\n'
1109 && ((*p
!= '.' && *p
!= ',') || (p
[1] && !isspace (p
[1]))))
1111 if (p
- str
> line_size
- 1)
1113 line_size
= p
- str
+ 1;
1114 xfree (line_buffer
);
1115 line_buffer
= (char *) xmalloc (line_size
);
1117 strncpy (line_buffer
, str
, p
- str
);
1118 line_buffer
[p
- str
] = '\0';
1119 if (islower (line_buffer
[0]))
1120 line_buffer
[0] = toupper (line_buffer
[0]);
1121 fputs_filtered (line_buffer
, stream
);
1124 /* Print one-line help for command C.
1125 If RECURSE is non-zero, also print one-line descriptions
1126 of all prefixed subcommands. */
1128 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
1129 struct ui_file
*stream
)
1131 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
1132 print_doc_line (stream
, c
->doc
);
1133 fputs_filtered ("\n", stream
);
1136 && c
->prefixlist
!= 0
1137 && c
->abbrev_flag
== 0)
1138 /* Subcommands of a prefix command typically have 'all_commands'
1139 as class. If we pass CLASS to recursive invocation,
1140 most often we won't see anything. */
1141 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 1, stream
);
1145 * Implement a help command on command list LIST.
1146 * RECURSE should be non-zero if this should be done recursively on
1147 * all sublists of LIST.
1148 * PREFIX is the prefix to print before each command name.
1149 * STREAM is the stream upon which the output should be written.
1151 * A non-negative class number to list only commands in that
1153 * ALL_COMMANDS to list all commands in list.
1154 * ALL_CLASSES to list all classes in list.
1156 * Note that RECURSE will be active on *all* sublists, not just the
1157 * ones selected by the criteria above (ie. the selection mechanism
1158 * is at the low level, not the high-level).
1161 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
1162 char *prefix
, int recurse
, struct ui_file
*stream
)
1164 struct cmd_list_element
*c
;
1166 for (c
= list
; c
; c
= c
->next
)
1168 if (c
->abbrev_flag
== 0
1169 && (class == all_commands
1170 || (class == all_classes
&& c
->func
== NULL
)
1171 || (class == c
->class && c
->func
!= NULL
)))
1173 print_help_for_command (c
, prefix
, recurse
, stream
);
1175 else if (c
->abbrev_flag
== 0 && recurse
1176 && class == class_user
&& c
->prefixlist
!= NULL
)
1177 /* User-defined commands may be subcommands. */
1178 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
,
1184 /* Search the input clist for 'command'. Return the command if
1185 found (or NULL if not), and return the number of commands
1188 static struct cmd_list_element
*
1189 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
1190 int ignore_help_classes
, int *nfound
)
1192 struct cmd_list_element
*found
, *c
;
1194 found
= (struct cmd_list_element
*) NULL
;
1196 for (c
= clist
; c
; c
= c
->next
)
1197 if (!strncmp (command
, c
->name
, len
)
1198 && (!ignore_help_classes
|| c
->func
))
1202 if (c
->name
[len
] == '\0')
1212 find_command_name_length (const char *text
)
1214 const char *p
= text
;
1216 /* Treating underscores as part of command words is important
1217 so that "set args_foo()" doesn't get interpreted as
1218 "set args _foo()". */
1219 /* Some characters are only used for TUI specific commands.
1220 However, they are always allowed for the sake of consistency.
1222 The XDB compatibility characters are only allowed when using the
1223 right mode because they clash with other GDB commands -
1224 specifically '/' is used as a suffix for print, examine and
1227 Note that this is larger than the character set allowed when
1228 creating user-defined commands. */
1230 /* Recognize '!' as a single character command so that, e.g., "!ls"
1231 works as expected. */
1235 while (isalnum (*p
) || *p
== '-' || *p
== '_'
1236 /* Characters used by TUI specific commands. */
1237 || *p
== '+' || *p
== '<' || *p
== '>' || *p
== '$'
1238 /* Characters used for XDB compatibility. */
1239 || (xdb_commands
&& (*p
== '/' || *p
== '?')))
1245 /* Return TRUE if NAME is a valid user-defined command name.
1246 This is a stricter subset of all gdb commands,
1247 see find_command_name_length. */
1250 valid_user_defined_cmd_name_p (const char *name
)
1257 /* Alas "42" is a legitimate user-defined command.
1258 In the interests of not breaking anything we preserve that. */
1260 for (p
= name
; *p
!= '\0'; ++p
)
1273 /* This routine takes a line of TEXT and a CLIST in which to start the
1274 lookup. When it returns it will have incremented the text pointer past
1275 the section of text it matched, set *RESULT_LIST to point to the list in
1276 which the last word was matched, and will return a pointer to the cmd
1277 list element which the text matches. It will return NULL if no match at
1278 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1279 matches are possible; in this case *RESULT_LIST will be set to point to
1280 the list in which there are ambiguous choices (and *TEXT will be set to
1281 the ambiguous text string).
1283 If the located command was an abbreviation, this routine returns the base
1284 command of the abbreviation.
1286 It does no error reporting whatsoever; control will always return
1287 to the superior routine.
1289 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1290 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1291 if no prefix command was ever found. For example, in the case of "info a",
1292 "info" matches without ambiguity, but "a" could be "args" or "address", so
1293 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1294 RESULT_LIST should not be interpeted as a pointer to the beginning of a
1295 list; it simply points to a specific command. In the case of an ambiguous
1296 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1297 "info t" can be "info types" or "info target"; upon return *TEXT has been
1298 advanced past "info ").
1300 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1301 affect the operation).
1303 This routine does *not* modify the text pointed to by TEXT.
1305 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1306 are actually help classes rather than commands (i.e. the function field of
1307 the struct cmd_list_element is NULL). */
1309 struct cmd_list_element
*
1310 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
1311 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1314 int len
, tmp
, nfound
;
1315 struct cmd_list_element
*found
, *c
;
1318 while (**text
== ' ' || **text
== '\t')
1321 /* Identify the name of the command. */
1322 len
= find_command_name_length (*text
);
1324 /* If nothing but whitespace, return 0. */
1328 /* *text and p now bracket the first command word to lookup (and
1329 it's length is len). We copy this into a local temporary. */
1332 command
= (char *) alloca (len
+ 1);
1333 memcpy (command
, *text
, len
);
1334 command
[len
] = '\0';
1339 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1341 /* We didn't find the command in the entered case, so lower case it
1342 and search again. */
1343 if (!found
|| nfound
== 0)
1345 for (tmp
= 0; tmp
< len
; tmp
++)
1347 char x
= command
[tmp
];
1349 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1351 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1354 /* If nothing matches, we have a simple failure. */
1360 if (result_list
!= NULL
)
1361 /* Will be modified in calling routine
1362 if we know what the prefix command is. */
1364 return CMD_LIST_AMBIGUOUS
; /* Ambiguous. */
1367 /* We've matched something on this list. Move text pointer forward. */
1371 if (found
->cmd_pointer
)
1373 /* We drop the alias (abbreviation) in favor of the command it
1374 is pointing to. If the alias is deprecated, though, we need to
1375 warn the user about it before we drop it. Note that while we
1376 are warning about the alias, we may also warn about the command
1377 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1380 if (found
->flags
& DEPRECATED_WARN_USER
)
1381 deprecated_cmd_warning (&line
);
1382 found
= found
->cmd_pointer
;
1384 /* If we found a prefix command, keep looking. */
1386 if (found
->prefixlist
)
1388 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1389 ignore_help_classes
);
1392 /* Didn't find anything; this is as far as we got. */
1393 if (result_list
!= NULL
)
1394 *result_list
= clist
;
1397 else if (c
== CMD_LIST_AMBIGUOUS
)
1399 /* We've gotten this far properly, but the next step is
1400 ambiguous. We need to set the result list to the best
1401 we've found (if an inferior hasn't already set it). */
1402 if (result_list
!= NULL
)
1404 /* This used to say *result_list = *found->prefixlist.
1405 If that was correct, need to modify the documentation
1406 at the top of this function to clarify what is
1407 supposed to be going on. */
1408 *result_list
= found
;
1419 if (result_list
!= NULL
)
1420 *result_list
= clist
;
1425 /* All this hair to move the space to the front of cmdtype */
1428 undef_cmd_error (char *cmdtype
, char *q
)
1430 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1433 *cmdtype
? " " : "",
1434 (int) strlen (cmdtype
) - 1,
1438 /* Look up the contents of *LINE as a command in the command list LIST.
1439 LIST is a chain of struct cmd_list_element's.
1440 If it is found, return the struct cmd_list_element for that command
1441 and update *LINE to point after the command name, at the first argument.
1442 If not found, call error if ALLOW_UNKNOWN is zero
1443 otherwise (or if error returns) return zero.
1444 Call error if specified command is ambiguous,
1445 unless ALLOW_UNKNOWN is negative.
1446 CMDTYPE precedes the word "command" in the error message.
1448 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1449 elements which are actually help classes rather than commands (i.e.
1450 the function field of the struct cmd_list_element is 0). */
1452 struct cmd_list_element
*
1453 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1454 int allow_unknown
, int ignore_help_classes
)
1456 struct cmd_list_element
*last_list
= 0;
1457 struct cmd_list_element
*c
;
1459 /* Note: Do not remove trailing whitespace here because this
1460 would be wrong for complete_command. Jim Kingdon */
1463 error (_("Lack of needed %scommand"), cmdtype
);
1465 c
= lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1472 int len
= find_command_name_length (*line
);
1474 q
= (char *) alloca (len
+ 1);
1475 strncpy (q
, *line
, len
);
1477 undef_cmd_error (cmdtype
, q
);
1482 else if (c
== CMD_LIST_AMBIGUOUS
)
1484 /* Ambigous. Local values should be off prefixlist or called
1486 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1488 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1489 struct cmd_list_element
*local_list
=
1490 (last_list
? *(last_list
->prefixlist
) : list
);
1492 if (local_allow_unknown
< 0)
1495 return last_list
; /* Found something. */
1497 return 0; /* Found nothing. */
1501 /* Report as error. */
1506 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1507 && (*line
)[amb_len
] != '\t');
1512 for (c
= local_list
; c
; c
= c
->next
)
1513 if (!strncmp (*line
, c
->name
, amb_len
))
1515 if (strlen (ambbuf
) + strlen (c
->name
) + 6
1516 < (int) sizeof ambbuf
)
1518 if (strlen (ambbuf
))
1519 strcat (ambbuf
, ", ");
1520 strcat (ambbuf
, c
->name
);
1524 strcat (ambbuf
, "..");
1528 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1530 return 0; /* lint */
1535 /* We've got something. It may still not be what the caller
1536 wants (if this command *needs* a subcommand). */
1537 while (**line
== ' ' || **line
== '\t')
1540 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1541 undef_cmd_error (c
->prefixname
, *line
);
1543 /* Seems to be what he wants. Return it. */
1549 /* We are here presumably because an alias or command in *TEXT is
1550 deprecated and a warning message should be generated. This
1551 function decodes *TEXT and potentially generates a warning message
1554 Example for 'set endian big' which has a fictitious alias 'seb'.
1556 If alias wasn't used in *TEXT, and the command is deprecated:
1557 "warning: 'set endian big' is deprecated."
1559 If alias was used, and only the alias is deprecated:
1560 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1562 If alias was used and command is deprecated (regardless of whether
1563 the alias itself is deprecated:
1565 "warning: 'set endian big' (seb) is deprecated."
1567 After the message has been sent, clear the appropriate flags in the
1568 command and/or the alias so the user is no longer bothered.
1572 deprecated_cmd_warning (char **text
)
1574 struct cmd_list_element
*alias
= NULL
;
1575 struct cmd_list_element
*prefix_cmd
= NULL
;
1576 struct cmd_list_element
*cmd
= NULL
;
1578 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1579 /* Return if text doesn't evaluate to a command. */
1582 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1583 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1584 /* Return if nothing is deprecated. */
1587 printf_filtered ("Warning:");
1589 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1590 printf_filtered (" '%s', an alias for the", alias
->name
);
1592 printf_filtered (" command '");
1595 printf_filtered ("%s", prefix_cmd
->prefixname
);
1597 printf_filtered ("%s", cmd
->name
);
1599 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1600 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1602 printf_filtered ("' is deprecated.\n");
1605 /* If it is only the alias that is deprecated, we want to indicate
1606 the new alias, otherwise we'll indicate the new command. */
1608 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1610 if (alias
->replacement
)
1611 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1613 printf_filtered ("No alternative known.\n\n");
1617 if (cmd
->replacement
)
1618 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1620 printf_filtered ("No alternative known.\n\n");
1623 /* We've warned you, now we'll keep quiet. */
1625 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1627 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1631 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1632 Return 1 on success, 0 on failure.
1634 If LINE refers to an alias, *alias will point to that alias.
1636 If LINE is a postfix command (i.e. one that is preceded by a prefix
1637 command) set *prefix_cmd.
1639 Set *cmd to point to the command LINE indicates.
1641 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1642 exist, they are NULL when we return.
1646 lookup_cmd_composition (char *text
,
1647 struct cmd_list_element
**alias
,
1648 struct cmd_list_element
**prefix_cmd
,
1649 struct cmd_list_element
**cmd
)
1652 int len
, tmp
, nfound
;
1653 struct cmd_list_element
*cur_list
;
1654 struct cmd_list_element
*prev_cmd
;
1664 /* Go through as many command lists as we need to,
1665 to find the command TEXT refers to. */
1669 while (*text
== ' ' || *text
== '\t')
1672 /* Identify the name of the command. */
1673 len
= find_command_name_length (text
);
1675 /* If nothing but whitespace, return. */
1679 /* Text is the start of the first command word to lookup (and
1680 it's length is len). We copy this into a local temporary. */
1682 command
= (char *) alloca (len
+ 1);
1683 memcpy (command
, text
, len
);
1684 command
[len
] = '\0';
1689 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1691 /* We didn't find the command in the entered case, so lower case
1692 it and search again.
1694 if (!*cmd
|| nfound
== 0)
1696 for (tmp
= 0; tmp
< len
; tmp
++)
1698 char x
= command
[tmp
];
1700 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1702 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1705 if (*cmd
== CMD_LIST_AMBIGUOUS
)
1707 return 0; /* ambiguous */
1711 return 0; /* nothing found */
1714 if ((*cmd
)->cmd_pointer
)
1716 /* cmd was actually an alias, we note that an alias was
1717 used (by assigning *alais) and we set *cmd. */
1719 *cmd
= (*cmd
)->cmd_pointer
;
1721 *prefix_cmd
= prev_cmd
;
1723 if ((*cmd
)->prefixlist
)
1724 cur_list
= *(*cmd
)->prefixlist
;
1732 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1734 /* Return a vector of char pointers which point to the different
1735 possible completions in LIST of TEXT.
1737 WORD points in the same buffer as TEXT, and completions should be
1738 returned relative to this position. For example, suppose TEXT is
1739 "foo" and we want to complete to "foobar". If WORD is "oo", return
1740 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1743 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
,
1744 int ignore_help_classes
)
1746 struct cmd_list_element
*ptr
;
1747 VEC (char_ptr
) *matchlist
= NULL
;
1748 int textlen
= strlen (text
);
1750 int saw_deprecated_match
= 0;
1752 /* We do one or two passes. In the first pass, we skip deprecated
1753 commands. If we see no matching commands in the first pass, and
1754 if we did happen to see a matching deprecated command, we do
1755 another loop to collect those. */
1756 for (pass
= 0; matchlist
== 0 && pass
< 2; ++pass
)
1758 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1759 if (!strncmp (ptr
->name
, text
, textlen
)
1760 && !ptr
->abbrev_flag
1761 && (!ignore_help_classes
|| ptr
->func
1762 || ptr
->prefixlist
))
1768 if ((ptr
->flags
& CMD_DEPRECATED
) != 0)
1770 saw_deprecated_match
= 1;
1775 match
= (char *) xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1777 strcpy (match
, ptr
->name
);
1778 else if (word
> text
)
1780 /* Return some portion of ptr->name. */
1781 strcpy (match
, ptr
->name
+ (word
- text
));
1785 /* Return some of text plus ptr->name. */
1786 strncpy (match
, word
, text
- word
);
1787 match
[text
- word
] = '\0';
1788 strcat (match
, ptr
->name
);
1790 VEC_safe_push (char_ptr
, matchlist
, match
);
1792 /* If we saw no matching deprecated commands in the first pass,
1794 if (!saw_deprecated_match
)
1801 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1803 /* Return a vector of char pointers which point to the different
1804 possible completions in CMD of TEXT.
1806 WORD points in the same buffer as TEXT, and completions should be
1807 returned relative to this position. For example, suppose TEXT is "foo"
1808 and we want to complete to "foobar". If WORD is "oo", return
1809 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1812 complete_on_enum (const char *const *enumlist
,
1816 VEC (char_ptr
) *matchlist
= NULL
;
1817 int textlen
= strlen (text
);
1821 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1822 if (strncmp (name
, text
, textlen
) == 0)
1826 match
= (char *) xmalloc (strlen (word
) + strlen (name
) + 1);
1828 strcpy (match
, name
);
1829 else if (word
> text
)
1831 /* Return some portion of name. */
1832 strcpy (match
, name
+ (word
- text
));
1836 /* Return some of text plus name. */
1837 strncpy (match
, word
, text
- word
);
1838 match
[text
- word
] = '\0';
1839 strcat (match
, name
);
1841 VEC_safe_push (char_ptr
, matchlist
, match
);
1848 /* Check function pointer. */
1850 cmd_func_p (struct cmd_list_element
*cmd
)
1852 return (cmd
->func
!= NULL
);
1856 /* Call the command function. */
1858 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1860 if (cmd_func_p (cmd
))
1861 (*cmd
->func
) (cmd
, args
, from_tty
);
1863 error (_("Invalid command"));