1 /* Handle lists of commands, their decoding and documentation, for GDB.
3 Copyright (c) 1986, 1989-1991, 1998, 2000-2002, 2004, 2007-2012 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 3 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, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_regex.h"
23 #include "gdb_string.h"
24 #include "completer.h"
27 #include "cli/cli-cmds.h"
28 #include "cli/cli-decode.h"
31 #include "tui/tui.h" /* For tui_active et al. */
34 #include "gdb_assert.h"
36 /* Prototypes for local functions. */
38 static void undef_cmd_error (char *, char *);
40 static struct cmd_list_element
*delete_cmd (char *name
,
41 struct cmd_list_element
**list
,
42 struct cmd_list_element
**prehook
,
43 struct cmd_list_element
**prehookee
,
44 struct cmd_list_element
**posthook
,
45 struct cmd_list_element
**posthookee
);
47 static struct cmd_list_element
*find_cmd (char *command
,
49 struct cmd_list_element
*clist
,
50 int ignore_help_classes
,
53 static void help_all (struct ui_file
*stream
);
55 /* Look up a command whose 'prefixlist' is KEY. Return the command if found,
56 otherwise return NULL. */
58 static struct cmd_list_element
*
59 lookup_cmd_for_prefixlist (struct cmd_list_element
**key
,
60 struct cmd_list_element
*list
)
62 struct cmd_list_element
*p
= NULL
;
64 for (p
= list
; p
!= NULL
; p
= p
->next
)
66 struct cmd_list_element
*q
;
68 if (p
->prefixlist
== NULL
)
70 else if (p
->prefixlist
== key
)
73 q
= lookup_cmd_for_prefixlist (key
, *(p
->prefixlist
));
82 set_cmd_prefix (struct cmd_list_element
*c
, struct cmd_list_element
**list
)
84 struct cmd_list_element
*p
;
86 /* Check to see if *LIST contains any element other than C. */
87 for (p
= *list
; p
!= NULL
; p
= p
->next
)
93 /* *SET_LIST only contains SET. */
94 p
= lookup_cmd_for_prefixlist (list
, setlist
);
96 c
->prefix
= p
? (p
->cmd_pointer
? p
->cmd_pointer
: p
) : p
;
99 c
->prefix
= p
->prefix
;
103 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
104 struct ui_file
*stream
);
107 /* Set the callback function for the specified command. For each both
108 the commands callback and func() are set. The latter set to a
109 bounce function (unless cfunc / sfunc is NULL that is). */
112 do_cfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
114 c
->function
.cfunc (args
, from_tty
); /* Ok. */
118 set_cmd_cfunc (struct cmd_list_element
*cmd
, cmd_cfunc_ftype
*cfunc
)
123 cmd
->func
= do_cfunc
;
124 cmd
->function
.cfunc
= cfunc
; /* Ok. */
128 do_sfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
130 c
->function
.sfunc (args
, from_tty
, c
); /* Ok. */
134 set_cmd_sfunc (struct cmd_list_element
*cmd
, cmd_sfunc_ftype
*sfunc
)
139 cmd
->func
= do_sfunc
;
140 cmd
->function
.sfunc
= sfunc
; /* Ok. */
144 cmd_cfunc_eq (struct cmd_list_element
*cmd
,
145 void (*cfunc
) (char *args
, int from_tty
))
147 return cmd
->func
== do_cfunc
&& cmd
->function
.cfunc
== cfunc
;
151 set_cmd_context (struct cmd_list_element
*cmd
, void *context
)
153 cmd
->context
= context
;
157 get_cmd_context (struct cmd_list_element
*cmd
)
163 cmd_type (struct cmd_list_element
*cmd
)
169 set_cmd_completer (struct cmd_list_element
*cmd
, completer_ftype
*completer
)
171 cmd
->completer
= completer
; /* Ok. */
174 /* Add element named NAME.
175 Space for NAME and DOC must be allocated by the caller.
176 CLASS is the top level category into which commands are broken down
178 FUN should be the function to execute the command;
179 it will get a character string as argument, with leading
180 and trailing blanks already eliminated.
182 DOC is a documentation string for the command.
183 Its first line should be a complete sentence.
184 It should start with ? for a command that is an abbreviation
185 or with * for a command that most users don't need to know about.
187 Add this command to command list *LIST.
189 Returns a pointer to the added command (not necessarily the head
192 struct cmd_list_element
*
193 add_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
194 char *doc
, struct cmd_list_element
**list
)
196 struct cmd_list_element
*c
197 = (struct cmd_list_element
*) xmalloc (sizeof (struct cmd_list_element
));
198 struct cmd_list_element
*p
, *iter
;
200 /* Turn each alias of the old command into an alias of the new
202 c
->aliases
= delete_cmd (name
, list
, &c
->hook_pre
, &c
->hookee_pre
,
203 &c
->hook_post
, &c
->hookee_post
);
204 for (iter
= c
->aliases
; iter
; iter
= iter
->alias_chain
)
205 iter
->cmd_pointer
= c
;
207 c
->hook_pre
->hookee_pre
= c
;
209 c
->hookee_pre
->hook_pre
= c
;
211 c
->hook_post
->hookee_post
= c
;
213 c
->hookee_post
->hook_post
= c
;
215 if (*list
== NULL
|| strcmp ((*list
)->name
, name
) >= 0)
223 while (p
->next
&& strcmp (p
->next
->name
, name
) <= 0)
233 set_cmd_cfunc (c
, fun
);
234 set_cmd_context (c
, NULL
);
237 c
->replacement
= NULL
;
238 c
->pre_show_hook
= NULL
;
240 c
->prefixlist
= NULL
;
241 c
->prefixname
= NULL
;
242 c
->allow_unknown
= 0;
245 set_cmd_completer (c
, make_symbol_completion_list_fn
);
247 c
->type
= not_set_cmd
;
249 c
->var_type
= var_boolean
;
251 c
->user_commands
= NULL
;
252 c
->cmd_pointer
= NULL
;
253 c
->alias_chain
= NULL
;
258 /* Deprecates a command CMD.
259 REPLACEMENT is the name of the command which should be used in
260 place of this command, or NULL if no such command exists.
262 This function does not check to see if command REPLACEMENT exists
263 since gdb may not have gotten around to adding REPLACEMENT when
264 this function is called.
266 Returns a pointer to the deprecated command. */
268 struct cmd_list_element
*
269 deprecate_cmd (struct cmd_list_element
*cmd
, char *replacement
)
271 cmd
->flags
|= (CMD_DEPRECATED
| DEPRECATED_WARN_USER
);
273 if (replacement
!= NULL
)
274 cmd
->replacement
= replacement
;
276 cmd
->replacement
= NULL
;
281 struct cmd_list_element
*
282 add_alias_cmd (char *name
, char *oldname
, enum command_class
class,
283 int abbrev_flag
, struct cmd_list_element
**list
)
285 /* Must do this since lookup_cmd tries to side-effect its first
288 struct cmd_list_element
*old
;
289 struct cmd_list_element
*c
;
291 copied_name
= (char *) alloca (strlen (oldname
) + 1);
292 strcpy (copied_name
, oldname
);
293 old
= lookup_cmd (&copied_name
, *list
, "", 1, 1);
297 struct cmd_list_element
*prehook
, *prehookee
, *posthook
, *posthookee
;
298 struct cmd_list_element
*aliases
= delete_cmd (name
, list
,
299 &prehook
, &prehookee
,
300 &posthook
, &posthookee
);
302 /* If this happens, it means a programmer error somewhere. */
303 gdb_assert (!aliases
&& !prehook
&& !prehookee
304 && !posthook
&& ! posthookee
);
308 c
= add_cmd (name
, class, NULL
, old
->doc
, list
);
310 /* If OLD->DOC can be freed, we should make another copy. */
311 if ((old
->flags
& DOC_ALLOCATED
) != 0)
313 c
->doc
= xstrdup (old
->doc
);
314 c
->flags
|= DOC_ALLOCATED
;
316 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
318 c
->function
= old
->function
;
319 c
->prefixlist
= old
->prefixlist
;
320 c
->prefixname
= old
->prefixname
;
321 c
->allow_unknown
= old
->allow_unknown
;
322 c
->abbrev_flag
= abbrev_flag
;
323 c
->cmd_pointer
= old
;
324 c
->alias_chain
= old
->aliases
;
327 set_cmd_prefix (c
, list
);
331 /* Like add_cmd but adds an element for a command prefix: a name that
332 should be followed by a subcommand to be looked up in another
333 command list. PREFIXLIST should be the address of the variable
334 containing that list. */
336 struct cmd_list_element
*
337 add_prefix_cmd (char *name
, enum command_class
class,
338 void (*fun
) (char *, int),
339 char *doc
, struct cmd_list_element
**prefixlist
,
340 char *prefixname
, int allow_unknown
,
341 struct cmd_list_element
**list
)
343 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
344 struct cmd_list_element
*p
;
346 c
->prefixlist
= prefixlist
;
347 c
->prefixname
= prefixname
;
348 c
->allow_unknown
= allow_unknown
;
350 if (list
== &cmdlist
)
353 set_cmd_prefix (c
, list
);
355 /* Update the field 'prefix' of each cmd_list_element in *PREFIXLIST. */
356 for (p
= *prefixlist
; p
!= NULL
; p
= p
->next
)
362 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
364 struct cmd_list_element
*
365 add_abbrev_prefix_cmd (char *name
, enum command_class
class,
366 void (*fun
) (char *, int), char *doc
,
367 struct cmd_list_element
**prefixlist
, char *prefixname
,
368 int allow_unknown
, struct cmd_list_element
**list
)
370 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
372 c
->prefixlist
= prefixlist
;
373 c
->prefixname
= prefixname
;
374 c
->allow_unknown
= allow_unknown
;
379 /* This is an empty "cfunc". */
381 not_just_help_class_command (char *args
, int from_tty
)
385 /* This is an empty "sfunc". */
386 static void empty_sfunc (char *, int, struct cmd_list_element
*);
389 empty_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
393 /* Add element named NAME to command list LIST (the list for set/show
394 or some sublist thereof).
395 TYPE is set_cmd or show_cmd.
396 CLASS is as in add_cmd.
397 VAR_TYPE is the kind of thing we are setting.
398 VAR is address of the variable being controlled by this command.
399 DOC is the documentation string. */
401 static struct cmd_list_element
*
402 add_set_or_show_cmd (char *name
,
404 enum command_class
class,
408 struct cmd_list_element
**list
)
410 struct cmd_list_element
*c
= add_cmd (name
, class, NULL
, doc
, list
);
412 gdb_assert (type
== set_cmd
|| type
== show_cmd
);
414 c
->var_type
= var_type
;
416 /* This needs to be something besides NULL so that this isn't
417 treated as a help class. */
418 set_cmd_sfunc (c
, empty_sfunc
);
422 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
423 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
424 setting. VAR is address of the variable being controlled by this
425 command. SET_FUNC and SHOW_FUNC are the callback functions (if
426 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
427 strings. PRINT the format string to print the value. SET_RESULT
428 and SHOW_RESULT, if not NULL, are set to the resulting command
432 add_setshow_cmd_full (char *name
,
433 enum command_class
class,
434 var_types var_type
, void *var
,
435 const char *set_doc
, const char *show_doc
,
436 const char *help_doc
,
437 cmd_sfunc_ftype
*set_func
,
438 show_value_ftype
*show_func
,
439 struct cmd_list_element
**set_list
,
440 struct cmd_list_element
**show_list
,
441 struct cmd_list_element
**set_result
,
442 struct cmd_list_element
**show_result
)
444 struct cmd_list_element
*set
;
445 struct cmd_list_element
*show
;
449 if (help_doc
!= NULL
)
451 full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
452 full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
456 full_set_doc
= xstrdup (set_doc
);
457 full_show_doc
= xstrdup (show_doc
);
459 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
460 full_set_doc
, set_list
);
461 set
->flags
|= DOC_ALLOCATED
;
463 if (set_func
!= NULL
)
464 set_cmd_sfunc (set
, set_func
);
466 set_cmd_prefix (set
, set_list
);
468 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
469 full_show_doc
, show_list
);
470 show
->flags
|= DOC_ALLOCATED
;
471 show
->show_value_func
= show_func
;
473 if (set_result
!= NULL
)
475 if (show_result
!= NULL
)
479 /* Add element named NAME to command list LIST (the list for set or
480 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
481 of strings which may follow NAME. VAR is address of the variable
482 which will contain the matching string (from ENUMLIST). */
485 add_setshow_enum_cmd (char *name
,
486 enum command_class
class,
487 const char *const *enumlist
,
490 const char *show_doc
,
491 const char *help_doc
,
492 cmd_sfunc_ftype
*set_func
,
493 show_value_ftype
*show_func
,
494 struct cmd_list_element
**set_list
,
495 struct cmd_list_element
**show_list
)
497 struct cmd_list_element
*c
;
499 add_setshow_cmd_full (name
, class, var_enum
, var
,
500 set_doc
, show_doc
, help_doc
,
507 const char * const auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
509 /* Add an auto-boolean command named NAME to both the set and show
510 command list lists. CLASS is as in add_cmd. VAR is address of the
511 variable which will contain the value. DOC is the documentation
512 string. FUNC is the corresponding callback. */
514 add_setshow_auto_boolean_cmd (char *name
,
515 enum command_class
class,
516 enum auto_boolean
*var
,
517 const char *set_doc
, const char *show_doc
,
518 const char *help_doc
,
519 cmd_sfunc_ftype
*set_func
,
520 show_value_ftype
*show_func
,
521 struct cmd_list_element
**set_list
,
522 struct cmd_list_element
**show_list
)
524 struct cmd_list_element
*c
;
526 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
527 set_doc
, show_doc
, help_doc
,
531 c
->enums
= auto_boolean_enums
;
534 /* Add element named NAME to both the set and show command LISTs (the
535 list for set/show or some sublist thereof). CLASS is as in
536 add_cmd. VAR is address of the variable which will contain the
537 value. SET_DOC and SHOW_DOC are the documentation strings. */
539 add_setshow_boolean_cmd (char *name
, enum command_class
class, int *var
,
540 const char *set_doc
, const char *show_doc
,
541 const char *help_doc
,
542 cmd_sfunc_ftype
*set_func
,
543 show_value_ftype
*show_func
,
544 struct cmd_list_element
**set_list
,
545 struct cmd_list_element
**show_list
)
547 static const char *boolean_enums
[] = { "on", "off", NULL
};
548 struct cmd_list_element
*c
;
550 add_setshow_cmd_full (name
, class, var_boolean
, var
,
551 set_doc
, show_doc
, help_doc
,
555 c
->enums
= boolean_enums
;
558 /* Add element named NAME to both the set and show command LISTs (the
559 list for set/show or some sublist thereof). */
561 add_setshow_filename_cmd (char *name
, enum command_class
class,
563 const char *set_doc
, const char *show_doc
,
564 const char *help_doc
,
565 cmd_sfunc_ftype
*set_func
,
566 show_value_ftype
*show_func
,
567 struct cmd_list_element
**set_list
,
568 struct cmd_list_element
**show_list
)
570 struct cmd_list_element
*set_result
;
572 add_setshow_cmd_full (name
, class, var_filename
, var
,
573 set_doc
, show_doc
, help_doc
,
577 set_cmd_completer (set_result
, filename_completer
);
580 /* Add element named NAME to both the set and show command LISTs (the
581 list for set/show or some sublist thereof). */
583 add_setshow_string_cmd (char *name
, enum command_class
class,
585 const char *set_doc
, const char *show_doc
,
586 const char *help_doc
,
587 cmd_sfunc_ftype
*set_func
,
588 show_value_ftype
*show_func
,
589 struct cmd_list_element
**set_list
,
590 struct cmd_list_element
**show_list
)
592 add_setshow_cmd_full (name
, class, var_string
, var
,
593 set_doc
, show_doc
, help_doc
,
599 /* Add element named NAME to both the set and show command LISTs (the
600 list for set/show or some sublist thereof). */
602 add_setshow_string_noescape_cmd (char *name
, enum command_class
class,
604 const char *set_doc
, const char *show_doc
,
605 const char *help_doc
,
606 cmd_sfunc_ftype
*set_func
,
607 show_value_ftype
*show_func
,
608 struct cmd_list_element
**set_list
,
609 struct cmd_list_element
**show_list
)
611 add_setshow_cmd_full (name
, class, var_string_noescape
, var
,
612 set_doc
, show_doc
, help_doc
,
618 /* Add element named NAME to both the set and show command LISTs (the
619 list for set/show or some sublist thereof). */
621 add_setshow_optional_filename_cmd (char *name
, enum command_class
class,
623 const char *set_doc
, const char *show_doc
,
624 const char *help_doc
,
625 cmd_sfunc_ftype
*set_func
,
626 show_value_ftype
*show_func
,
627 struct cmd_list_element
**set_list
,
628 struct cmd_list_element
**show_list
)
630 struct cmd_list_element
*set_result
;
632 add_setshow_cmd_full (name
, class, var_optional_filename
, var
,
633 set_doc
, show_doc
, help_doc
,
638 set_cmd_completer (set_result
, filename_completer
);
642 /* Add element named NAME to both the set and show command LISTs (the
643 list for set/show or some sublist thereof). CLASS is as in
644 add_cmd. VAR is address of the variable which will contain the
645 value. SET_DOC and SHOW_DOC are the documentation strings. This
646 function is only used in Python API. Please don't use it elsewhere. */
648 add_setshow_integer_cmd (char *name
, enum command_class
class,
650 const char *set_doc
, const char *show_doc
,
651 const char *help_doc
,
652 cmd_sfunc_ftype
*set_func
,
653 show_value_ftype
*show_func
,
654 struct cmd_list_element
**set_list
,
655 struct cmd_list_element
**show_list
)
657 add_setshow_cmd_full (name
, class, var_integer
, var
,
658 set_doc
, show_doc
, help_doc
,
664 /* Add element named NAME to both the set and show command LISTs (the
665 list for set/show or some sublist thereof). CLASS is as in
666 add_cmd. VAR is address of the variable which will contain the
667 value. SET_DOC and SHOW_DOC are the documentation strings. */
669 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
671 const char *set_doc
, const char *show_doc
,
672 const char *help_doc
,
673 cmd_sfunc_ftype
*set_func
,
674 show_value_ftype
*show_func
,
675 struct cmd_list_element
**set_list
,
676 struct cmd_list_element
**show_list
)
678 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
679 set_doc
, show_doc
, help_doc
,
685 /* Add element named NAME to both the set and show command LISTs (the
686 list for set/show or some sublist thereof). CLASS is as in
687 add_cmd. VAR is address of the variable which will contain the
688 value. SET_DOC and SHOW_DOC are the documentation strings. */
690 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
692 const char *set_doc
, const char *show_doc
,
693 const char *help_doc
,
694 cmd_sfunc_ftype
*set_func
,
695 show_value_ftype
*show_func
,
696 struct cmd_list_element
**set_list
,
697 struct cmd_list_element
**show_list
)
699 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
700 set_doc
, show_doc
, help_doc
,
707 add_setshow_zuinteger_unlimited_cmd (char *name
,
708 enum command_class
class,
711 const char *show_doc
,
712 const char *help_doc
,
713 cmd_sfunc_ftype
*set_func
,
714 show_value_ftype
*show_func
,
715 struct cmd_list_element
**set_list
,
716 struct cmd_list_element
**show_list
)
718 add_setshow_cmd_full (name
, class, var_zuinteger_unlimited
, var
,
719 set_doc
, show_doc
, help_doc
,
725 /* Add element named NAME to both the set and show command LISTs (the
726 list for set/show or some sublist thereof). CLASS is as in
727 add_cmd. VAR is address of the variable which will contain the
728 value. SET_DOC and SHOW_DOC are the documentation strings. */
730 add_setshow_zuinteger_cmd (char *name
, enum command_class
class,
732 const char *set_doc
, const char *show_doc
,
733 const char *help_doc
,
734 cmd_sfunc_ftype
*set_func
,
735 show_value_ftype
*show_func
,
736 struct cmd_list_element
**set_list
,
737 struct cmd_list_element
**show_list
)
739 add_setshow_cmd_full (name
, class, var_zuinteger
, var
,
740 set_doc
, show_doc
, help_doc
,
746 /* Remove the command named NAME from the command list. Return the
747 list commands which were aliased to the deleted command. If the
748 command had no aliases, return NULL. The various *HOOKs are set to
749 the pre- and post-hook commands for the deleted command. If the
750 command does not have a hook, the corresponding out parameter is
753 static struct cmd_list_element
*
754 delete_cmd (char *name
, struct cmd_list_element
**list
,
755 struct cmd_list_element
**prehook
,
756 struct cmd_list_element
**prehookee
,
757 struct cmd_list_element
**posthook
,
758 struct cmd_list_element
**posthookee
)
760 struct cmd_list_element
*iter
;
761 struct cmd_list_element
**previous_chain_ptr
;
762 struct cmd_list_element
*aliases
= NULL
;
768 previous_chain_ptr
= list
;
770 for (iter
= *previous_chain_ptr
; iter
; iter
= *previous_chain_ptr
)
772 if (strcmp (iter
->name
, name
) == 0)
775 iter
->destroyer (iter
, iter
->context
);
776 if (iter
->hookee_pre
)
777 iter
->hookee_pre
->hook_pre
= 0;
778 *prehook
= iter
->hook_pre
;
779 *prehookee
= iter
->hookee_pre
;
780 if (iter
->hookee_post
)
781 iter
->hookee_post
->hook_post
= 0;
782 if (iter
->doc
&& (iter
->flags
& DOC_ALLOCATED
) != 0)
784 *posthook
= iter
->hook_post
;
785 *posthookee
= iter
->hookee_post
;
787 /* Update the link. */
788 *previous_chain_ptr
= iter
->next
;
790 aliases
= iter
->aliases
;
792 /* If this command was an alias, remove it from the list of
794 if (iter
->cmd_pointer
)
796 struct cmd_list_element
**prevp
= &iter
->cmd_pointer
->aliases
;
797 struct cmd_list_element
*a
= *prevp
;
801 prevp
= &a
->alias_chain
;
804 *prevp
= iter
->alias_chain
;
809 /* We won't see another command with the same name. */
813 previous_chain_ptr
= &iter
->next
;
819 /* Shorthands to the commands above. */
821 /* Add an element to the list of info subcommands. */
823 struct cmd_list_element
*
824 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
826 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
829 /* Add an alias to the list of info subcommands. */
831 struct cmd_list_element
*
832 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
834 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
837 /* Add an element to the list of commands. */
839 struct cmd_list_element
*
840 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
843 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
846 /* Add an alias or abbreviation command to the list of commands. */
848 struct cmd_list_element
*
849 add_com_alias (char *name
, char *oldname
, enum command_class
class,
852 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
855 /* Recursively walk the commandlist structures, and print out the
856 documentation of commands that match our regex in either their
857 name, or their documentation.
860 apropos_cmd (struct ui_file
*stream
,
861 struct cmd_list_element
*commandlist
,
862 struct re_pattern_buffer
*regex
, char *prefix
)
864 struct cmd_list_element
*c
;
867 /* Walk through the commands. */
868 for (c
=commandlist
;c
;c
=c
->next
)
870 returnvalue
= -1; /* Needed to avoid double printing. */
873 /* Try to match against the name. */
874 returnvalue
= re_search (regex
, c
->name
, strlen(c
->name
),
875 0, strlen (c
->name
), NULL
);
876 if (returnvalue
>= 0)
878 print_help_for_command (c
, prefix
,
879 0 /* don't recurse */, stream
);
882 if (c
->doc
!= NULL
&& returnvalue
< 0)
884 /* Try to match against documentation. */
885 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
887 print_help_for_command (c
, prefix
,
888 0 /* don't recurse */, stream
);
891 /* Check if this command has subcommands and is not an
892 abbreviation. We skip listing subcommands of abbreviations
893 in order to avoid duplicates in the output. */
894 if (c
->prefixlist
!= NULL
&& !c
->abbrev_flag
)
896 /* Recursively call ourselves on the subcommand list,
897 passing the right prefix in. */
898 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
903 /* This command really has to deal with two things:
904 1) I want documentation on *this string* (usually called by
907 2) I want documentation on *this list* (usually called by giving a
908 command that requires subcommands. Also called by saying just
911 I am going to split this into two seperate comamnds, help_cmd and
915 help_cmd (char *command
, struct ui_file
*stream
)
917 struct cmd_list_element
*c
;
918 extern struct cmd_list_element
*cmdlist
;
922 help_list (cmdlist
, "", all_classes
, stream
);
926 if (strcmp (command
, "all") == 0)
932 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
937 /* There are three cases here.
938 If c->prefixlist is nonzero, we have a prefix command.
939 Print its documentation, then list its subcommands.
941 If c->func is non NULL, we really have a command. Print its
942 documentation and return.
944 If c->func is NULL, we have a class name. Print its
945 documentation (as if it were a command) and then set class to the
946 number of this class so that the commands in the class will be
949 fputs_filtered (c
->doc
, stream
);
950 fputs_filtered ("\n", stream
);
952 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
954 fprintf_filtered (stream
, "\n");
956 /* If this is a prefix command, print it's subcommands. */
958 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
960 /* If this is a class name, print all of the commands in the class. */
962 help_list (cmdlist
, "", c
->class, stream
);
964 if (c
->hook_pre
|| c
->hook_post
)
965 fprintf_filtered (stream
,
966 "\nThis command has a hook (or hooks) defined:\n");
969 fprintf_filtered (stream
,
970 "\tThis command is run after : %s (pre hook)\n",
973 fprintf_filtered (stream
,
974 "\tThis command is run before : %s (post hook)\n",
979 * Get a specific kind of help on a command list.
982 * CMDTYPE is the prefix to use in the title string.
983 * CLASS is the class with which to list the nodes of this list (see
984 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
985 * everything, ALL_CLASSES for just classes, and non-negative for only things
986 * in a specific class.
987 * and STREAM is the output stream on which to print things.
988 * If you call this routine with a class >= 0, it recurses.
991 help_list (struct cmd_list_element
*list
, char *cmdtype
,
992 enum command_class
class, struct ui_file
*stream
)
995 char *cmdtype1
, *cmdtype2
;
997 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
999 len
= strlen (cmdtype
);
1000 cmdtype1
= (char *) alloca (len
+ 1);
1002 cmdtype2
= (char *) alloca (len
+ 4);
1007 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
1009 strncpy (cmdtype2
, cmdtype
, len
- 1);
1010 strcpy (cmdtype2
+ len
- 1, " sub");
1013 if (class == all_classes
)
1014 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
1016 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
1018 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
1020 if (class == all_classes
)
1022 fprintf_filtered (stream
, "\n\
1023 Type \"help%s\" followed by a class name for a list of commands in ",
1026 fprintf_filtered (stream
, "that class.");
1028 fprintf_filtered (stream
, "\n\
1029 Type \"help all\" for the list of all commands.");
1032 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
1033 cmdtype1
, cmdtype2
);
1035 fputs_filtered ("for ", stream
);
1037 fputs_filtered ("full ", stream
);
1039 fputs_filtered ("documentation.\n", stream
);
1040 fputs_filtered ("Type \"apropos word\" to search "
1041 "for commands related to \"word\".\n", stream
);
1042 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
1047 help_all (struct ui_file
*stream
)
1049 struct cmd_list_element
*c
;
1050 extern struct cmd_list_element
*cmdlist
;
1051 int seen_unclassified
= 0;
1053 for (c
= cmdlist
; c
; c
= c
->next
)
1057 /* If this is a class name, print all of the commands in the
1060 if (c
->func
== NULL
)
1062 fprintf_filtered (stream
, "\nCommand class: %s\n\n", c
->name
);
1063 help_cmd_list (cmdlist
, c
->class, "", 1, stream
);
1067 /* While it's expected that all commands are in some class,
1068 as a safety measure, we'll print commands outside of any
1069 class at the end. */
1071 for (c
= cmdlist
; c
; c
= c
->next
)
1076 if (c
->class == no_class
)
1078 if (!seen_unclassified
)
1080 fprintf_filtered (stream
, "\nUnclassified commands\n\n");
1081 seen_unclassified
= 1;
1083 print_help_for_command (c
, "", 1, stream
);
1089 /* Print only the first line of STR on STREAM. */
1091 print_doc_line (struct ui_file
*stream
, char *str
)
1093 static char *line_buffer
= 0;
1094 static int line_size
;
1100 line_buffer
= (char *) xmalloc (line_size
);
1103 /* Keep printing '.' or ',' not followed by a whitespace for embedded strings
1106 while (*p
&& *p
!= '\n'
1107 && ((*p
!= '.' && *p
!= ',') || (p
[1] && !isspace (p
[1]))))
1109 if (p
- str
> line_size
- 1)
1111 line_size
= p
- str
+ 1;
1112 xfree (line_buffer
);
1113 line_buffer
= (char *) xmalloc (line_size
);
1115 strncpy (line_buffer
, str
, p
- str
);
1116 line_buffer
[p
- str
] = '\0';
1117 if (islower (line_buffer
[0]))
1118 line_buffer
[0] = toupper (line_buffer
[0]);
1119 fputs_filtered (line_buffer
, stream
);
1122 /* Print one-line help for command C.
1123 If RECURSE is non-zero, also print one-line descriptions
1124 of all prefixed subcommands. */
1126 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
1127 struct ui_file
*stream
)
1129 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
1130 print_doc_line (stream
, c
->doc
);
1131 fputs_filtered ("\n", stream
);
1134 && c
->prefixlist
!= 0
1135 && c
->abbrev_flag
== 0)
1136 /* Subcommands of a prefix command typically have 'all_commands'
1137 as class. If we pass CLASS to recursive invocation,
1138 most often we won't see anything. */
1139 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 1, stream
);
1143 * Implement a help command on command list LIST.
1144 * RECURSE should be non-zero if this should be done recursively on
1145 * all sublists of LIST.
1146 * PREFIX is the prefix to print before each command name.
1147 * STREAM is the stream upon which the output should be written.
1149 * A non-negative class number to list only commands in that
1151 * ALL_COMMANDS to list all commands in list.
1152 * ALL_CLASSES to list all classes in list.
1154 * Note that RECURSE will be active on *all* sublists, not just the
1155 * ones selected by the criteria above (ie. the selection mechanism
1156 * is at the low level, not the high-level).
1159 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
1160 char *prefix
, int recurse
, struct ui_file
*stream
)
1162 struct cmd_list_element
*c
;
1164 for (c
= list
; c
; c
= c
->next
)
1166 if (c
->abbrev_flag
== 0
1167 && (class == all_commands
1168 || (class == all_classes
&& c
->func
== NULL
)
1169 || (class == c
->class && c
->func
!= NULL
)))
1171 print_help_for_command (c
, prefix
, recurse
, stream
);
1173 else if (c
->abbrev_flag
== 0 && recurse
1174 && class == class_user
&& c
->prefixlist
!= NULL
)
1175 /* User-defined commands may be subcommands. */
1176 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
,
1182 /* Search the input clist for 'command'. Return the command if
1183 found (or NULL if not), and return the number of commands
1186 static struct cmd_list_element
*
1187 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
1188 int ignore_help_classes
, int *nfound
)
1190 struct cmd_list_element
*found
, *c
;
1192 found
= (struct cmd_list_element
*) NULL
;
1194 for (c
= clist
; c
; c
= c
->next
)
1195 if (!strncmp (command
, c
->name
, len
)
1196 && (!ignore_help_classes
|| c
->func
))
1200 if (c
->name
[len
] == '\0')
1210 find_command_name_length (const char *text
)
1212 const char *p
= text
;
1214 /* Treating underscores as part of command words is important
1215 so that "set args_foo()" doesn't get interpreted as
1216 "set args _foo()". */
1217 /* Some characters are only used for TUI specific commands.
1218 However, they are always allowed for the sake of consistency.
1220 The XDB compatibility characters are only allowed when using the
1221 right mode because they clash with other GDB commands -
1222 specifically '/' is used as a suffix for print, examine and
1225 Note that this is larger than the character set allowed when
1226 creating user-defined commands. */
1228 /* Recognize '!' as a single character command so that, e.g., "!ls"
1229 works as expected. */
1233 while (isalnum (*p
) || *p
== '-' || *p
== '_'
1234 /* Characters used by TUI specific commands. */
1235 || *p
== '+' || *p
== '<' || *p
== '>' || *p
== '$'
1236 /* Characters used for XDB compatibility. */
1237 || (xdb_commands
&& (*p
== '/' || *p
== '?')))
1243 /* Return TRUE if NAME is a valid user-defined command name.
1244 This is a stricter subset of all gdb commands,
1245 see find_command_name_length. */
1248 valid_user_defined_cmd_name_p (const char *name
)
1255 /* Alas "42" is a legitimate user-defined command.
1256 In the interests of not breaking anything we preserve that. */
1258 for (p
= name
; *p
!= '\0'; ++p
)
1271 /* This routine takes a line of TEXT and a CLIST in which to start the
1272 lookup. When it returns it will have incremented the text pointer past
1273 the section of text it matched, set *RESULT_LIST to point to the list in
1274 which the last word was matched, and will return a pointer to the cmd
1275 list element which the text matches. It will return NULL if no match at
1276 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1277 matches are possible; in this case *RESULT_LIST will be set to point to
1278 the list in which there are ambiguous choices (and *TEXT will be set to
1279 the ambiguous text string).
1281 If the located command was an abbreviation, this routine returns the base
1282 command of the abbreviation.
1284 It does no error reporting whatsoever; control will always return
1285 to the superior routine.
1287 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1288 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1289 if no prefix command was ever found. For example, in the case of "info a",
1290 "info" matches without ambiguity, but "a" could be "args" or "address", so
1291 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1292 RESULT_LIST should not be interpeted as a pointer to the beginning of a
1293 list; it simply points to a specific command. In the case of an ambiguous
1294 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1295 "info t" can be "info types" or "info target"; upon return *TEXT has been
1296 advanced past "info ").
1298 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1299 affect the operation).
1301 This routine does *not* modify the text pointed to by TEXT.
1303 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1304 are actually help classes rather than commands (i.e. the function field of
1305 the struct cmd_list_element is NULL). */
1307 struct cmd_list_element
*
1308 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
1309 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1312 int len
, tmp
, nfound
;
1313 struct cmd_list_element
*found
, *c
;
1316 while (**text
== ' ' || **text
== '\t')
1319 /* Identify the name of the command. */
1320 len
= find_command_name_length (*text
);
1322 /* If nothing but whitespace, return 0. */
1326 /* *text and p now bracket the first command word to lookup (and
1327 it's length is len). We copy this into a local temporary. */
1330 command
= (char *) alloca (len
+ 1);
1331 memcpy (command
, *text
, len
);
1332 command
[len
] = '\0';
1337 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1339 /* We didn't find the command in the entered case, so lower case it
1340 and search again. */
1341 if (!found
|| nfound
== 0)
1343 for (tmp
= 0; tmp
< len
; tmp
++)
1345 char x
= command
[tmp
];
1347 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1349 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1352 /* If nothing matches, we have a simple failure. */
1358 if (result_list
!= NULL
)
1359 /* Will be modified in calling routine
1360 if we know what the prefix command is. */
1362 return CMD_LIST_AMBIGUOUS
; /* Ambiguous. */
1365 /* We've matched something on this list. Move text pointer forward. */
1369 if (found
->cmd_pointer
)
1371 /* We drop the alias (abbreviation) in favor of the command it
1372 is pointing to. If the alias is deprecated, though, we need to
1373 warn the user about it before we drop it. Note that while we
1374 are warning about the alias, we may also warn about the command
1375 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1378 if (found
->flags
& DEPRECATED_WARN_USER
)
1379 deprecated_cmd_warning (&line
);
1380 found
= found
->cmd_pointer
;
1382 /* If we found a prefix command, keep looking. */
1384 if (found
->prefixlist
)
1386 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1387 ignore_help_classes
);
1390 /* Didn't find anything; this is as far as we got. */
1391 if (result_list
!= NULL
)
1392 *result_list
= clist
;
1395 else if (c
== CMD_LIST_AMBIGUOUS
)
1397 /* We've gotten this far properly, but the next step is
1398 ambiguous. We need to set the result list to the best
1399 we've found (if an inferior hasn't already set it). */
1400 if (result_list
!= NULL
)
1402 /* This used to say *result_list = *found->prefixlist.
1403 If that was correct, need to modify the documentation
1404 at the top of this function to clarify what is
1405 supposed to be going on. */
1406 *result_list
= found
;
1417 if (result_list
!= NULL
)
1418 *result_list
= clist
;
1423 /* All this hair to move the space to the front of cmdtype */
1426 undef_cmd_error (char *cmdtype
, char *q
)
1428 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1431 *cmdtype
? " " : "",
1432 (int) strlen (cmdtype
) - 1,
1436 /* Look up the contents of *LINE as a command in the command list LIST.
1437 LIST is a chain of struct cmd_list_element's.
1438 If it is found, return the struct cmd_list_element for that command
1439 and update *LINE to point after the command name, at the first argument.
1440 If not found, call error if ALLOW_UNKNOWN is zero
1441 otherwise (or if error returns) return zero.
1442 Call error if specified command is ambiguous,
1443 unless ALLOW_UNKNOWN is negative.
1444 CMDTYPE precedes the word "command" in the error message.
1446 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1447 elements which are actually help classes rather than commands (i.e.
1448 the function field of the struct cmd_list_element is 0). */
1450 struct cmd_list_element
*
1451 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1452 int allow_unknown
, int ignore_help_classes
)
1454 struct cmd_list_element
*last_list
= 0;
1455 struct cmd_list_element
*c
;
1457 /* Note: Do not remove trailing whitespace here because this
1458 would be wrong for complete_command. Jim Kingdon */
1461 error (_("Lack of needed %scommand"), cmdtype
);
1463 c
= lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1470 int len
= find_command_name_length (*line
);
1472 q
= (char *) alloca (len
+ 1);
1473 strncpy (q
, *line
, len
);
1475 undef_cmd_error (cmdtype
, q
);
1480 else if (c
== CMD_LIST_AMBIGUOUS
)
1482 /* Ambigous. Local values should be off prefixlist or called
1484 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1486 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1487 struct cmd_list_element
*local_list
=
1488 (last_list
? *(last_list
->prefixlist
) : list
);
1490 if (local_allow_unknown
< 0)
1493 return last_list
; /* Found something. */
1495 return 0; /* Found nothing. */
1499 /* Report as error. */
1504 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1505 && (*line
)[amb_len
] != '\t');
1510 for (c
= local_list
; c
; c
= c
->next
)
1511 if (!strncmp (*line
, c
->name
, amb_len
))
1513 if (strlen (ambbuf
) + strlen (c
->name
) + 6
1514 < (int) sizeof ambbuf
)
1516 if (strlen (ambbuf
))
1517 strcat (ambbuf
, ", ");
1518 strcat (ambbuf
, c
->name
);
1522 strcat (ambbuf
, "..");
1526 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1528 return 0; /* lint */
1533 /* We've got something. It may still not be what the caller
1534 wants (if this command *needs* a subcommand). */
1535 while (**line
== ' ' || **line
== '\t')
1538 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1539 undef_cmd_error (c
->prefixname
, *line
);
1541 /* Seems to be what he wants. Return it. */
1547 /* We are here presumably because an alias or command in *TEXT is
1548 deprecated and a warning message should be generated. This
1549 function decodes *TEXT and potentially generates a warning message
1552 Example for 'set endian big' which has a fictitious alias 'seb'.
1554 If alias wasn't used in *TEXT, and the command is deprecated:
1555 "warning: 'set endian big' is deprecated."
1557 If alias was used, and only the alias is deprecated:
1558 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1560 If alias was used and command is deprecated (regardless of whether
1561 the alias itself is deprecated:
1563 "warning: 'set endian big' (seb) is deprecated."
1565 After the message has been sent, clear the appropriate flags in the
1566 command and/or the alias so the user is no longer bothered.
1570 deprecated_cmd_warning (char **text
)
1572 struct cmd_list_element
*alias
= NULL
;
1573 struct cmd_list_element
*prefix_cmd
= NULL
;
1574 struct cmd_list_element
*cmd
= NULL
;
1576 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1577 /* Return if text doesn't evaluate to a command. */
1580 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1581 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1582 /* Return if nothing is deprecated. */
1585 printf_filtered ("Warning:");
1587 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1588 printf_filtered (" '%s', an alias for the", alias
->name
);
1590 printf_filtered (" command '");
1593 printf_filtered ("%s", prefix_cmd
->prefixname
);
1595 printf_filtered ("%s", cmd
->name
);
1597 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1598 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1600 printf_filtered ("' is deprecated.\n");
1603 /* If it is only the alias that is deprecated, we want to indicate
1604 the new alias, otherwise we'll indicate the new command. */
1606 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1608 if (alias
->replacement
)
1609 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1611 printf_filtered ("No alternative known.\n\n");
1615 if (cmd
->replacement
)
1616 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1618 printf_filtered ("No alternative known.\n\n");
1621 /* We've warned you, now we'll keep quiet. */
1623 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1625 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1629 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1630 Return 1 on success, 0 on failure.
1632 If LINE refers to an alias, *alias will point to that alias.
1634 If LINE is a postfix command (i.e. one that is preceded by a prefix
1635 command) set *prefix_cmd.
1637 Set *cmd to point to the command LINE indicates.
1639 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1640 exist, they are NULL when we return.
1644 lookup_cmd_composition (char *text
,
1645 struct cmd_list_element
**alias
,
1646 struct cmd_list_element
**prefix_cmd
,
1647 struct cmd_list_element
**cmd
)
1650 int len
, tmp
, nfound
;
1651 struct cmd_list_element
*cur_list
;
1652 struct cmd_list_element
*prev_cmd
;
1662 /* Go through as many command lists as we need to,
1663 to find the command TEXT refers to. */
1667 while (*text
== ' ' || *text
== '\t')
1670 /* Identify the name of the command. */
1671 len
= find_command_name_length (text
);
1673 /* If nothing but whitespace, return. */
1677 /* Text is the start of the first command word to lookup (and
1678 it's length is len). We copy this into a local temporary. */
1680 command
= (char *) alloca (len
+ 1);
1681 memcpy (command
, text
, len
);
1682 command
[len
] = '\0';
1687 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1689 /* We didn't find the command in the entered case, so lower case
1690 it and search again.
1692 if (!*cmd
|| nfound
== 0)
1694 for (tmp
= 0; tmp
< len
; tmp
++)
1696 char x
= command
[tmp
];
1698 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1700 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1703 if (*cmd
== CMD_LIST_AMBIGUOUS
)
1705 return 0; /* ambiguous */
1709 return 0; /* nothing found */
1712 if ((*cmd
)->cmd_pointer
)
1714 /* cmd was actually an alias, we note that an alias was
1715 used (by assigning *alais) and we set *cmd. */
1717 *cmd
= (*cmd
)->cmd_pointer
;
1719 *prefix_cmd
= prev_cmd
;
1721 if ((*cmd
)->prefixlist
)
1722 cur_list
= *(*cmd
)->prefixlist
;
1730 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1732 /* Return a vector of char pointers which point to the different
1733 possible completions in LIST of TEXT.
1735 WORD points in the same buffer as TEXT, and completions should be
1736 returned relative to this position. For example, suppose TEXT is
1737 "foo" and we want to complete to "foobar". If WORD is "oo", return
1738 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1741 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
,
1742 int ignore_help_classes
)
1744 struct cmd_list_element
*ptr
;
1745 VEC (char_ptr
) *matchlist
= NULL
;
1746 int textlen
= strlen (text
);
1748 int saw_deprecated_match
= 0;
1750 /* We do one or two passes. In the first pass, we skip deprecated
1751 commands. If we see no matching commands in the first pass, and
1752 if we did happen to see a matching deprecated command, we do
1753 another loop to collect those. */
1754 for (pass
= 0; matchlist
== 0 && pass
< 2; ++pass
)
1756 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1757 if (!strncmp (ptr
->name
, text
, textlen
)
1758 && !ptr
->abbrev_flag
1759 && (!ignore_help_classes
|| ptr
->func
1760 || ptr
->prefixlist
))
1766 if ((ptr
->flags
& CMD_DEPRECATED
) != 0)
1768 saw_deprecated_match
= 1;
1773 match
= (char *) xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1775 strcpy (match
, ptr
->name
);
1776 else if (word
> text
)
1778 /* Return some portion of ptr->name. */
1779 strcpy (match
, ptr
->name
+ (word
- text
));
1783 /* Return some of text plus ptr->name. */
1784 strncpy (match
, word
, text
- word
);
1785 match
[text
- word
] = '\0';
1786 strcat (match
, ptr
->name
);
1788 VEC_safe_push (char_ptr
, matchlist
, match
);
1790 /* If we saw no matching deprecated commands in the first pass,
1792 if (!saw_deprecated_match
)
1799 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1801 /* Return a vector of char pointers which point to the different
1802 possible completions in CMD of TEXT.
1804 WORD points in the same buffer as TEXT, and completions should be
1805 returned relative to this position. For example, suppose TEXT is "foo"
1806 and we want to complete to "foobar". If WORD is "oo", return
1807 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1810 complete_on_enum (const char *const *enumlist
,
1814 VEC (char_ptr
) *matchlist
= NULL
;
1815 int textlen
= strlen (text
);
1819 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1820 if (strncmp (name
, text
, textlen
) == 0)
1824 match
= (char *) xmalloc (strlen (word
) + strlen (name
) + 1);
1826 strcpy (match
, name
);
1827 else if (word
> text
)
1829 /* Return some portion of name. */
1830 strcpy (match
, name
+ (word
- text
));
1834 /* Return some of text plus name. */
1835 strncpy (match
, word
, text
- word
);
1836 match
[text
- word
] = '\0';
1837 strcat (match
, name
);
1839 VEC_safe_push (char_ptr
, matchlist
, match
);
1846 /* Check function pointer. */
1848 cmd_func_p (struct cmd_list_element
*cmd
)
1850 return (cmd
->func
!= NULL
);
1854 /* Call the command function. */
1856 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1858 if (cmd_func_p (cmd
))
1859 (*cmd
->func
) (cmd
, args
, from_tty
);
1861 error (_("Invalid command"));