1 /* Handle lists of commands, their decoding and documentation, for GDB.
3 Copyright (C) 1986-2017 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 "completer.h"
24 #include "cli/cli-cmds.h"
25 #include "cli/cli-decode.h"
26 #include "common/gdb_optional.h"
28 /* Prototypes for local functions. */
30 static void undef_cmd_error (const char *, const char *);
32 static struct cmd_list_element
*delete_cmd (const char *name
,
33 struct cmd_list_element
**list
,
34 struct cmd_list_element
**prehook
,
35 struct cmd_list_element
**prehookee
,
36 struct cmd_list_element
**posthook
,
37 struct cmd_list_element
**posthookee
);
39 static struct cmd_list_element
*find_cmd (const char *command
,
41 struct cmd_list_element
*clist
,
42 int ignore_help_classes
,
45 static void help_all (struct ui_file
*stream
);
47 /* Look up a command whose 'prefixlist' is KEY. Return the command if found,
48 otherwise return NULL. */
50 static struct cmd_list_element
*
51 lookup_cmd_for_prefixlist (struct cmd_list_element
**key
,
52 struct cmd_list_element
*list
)
54 struct cmd_list_element
*p
= NULL
;
56 for (p
= list
; p
!= NULL
; p
= p
->next
)
58 struct cmd_list_element
*q
;
60 if (p
->prefixlist
== NULL
)
62 else if (p
->prefixlist
== key
)
65 q
= lookup_cmd_for_prefixlist (key
, *(p
->prefixlist
));
74 set_cmd_prefix (struct cmd_list_element
*c
, struct cmd_list_element
**list
)
76 struct cmd_list_element
*p
;
78 /* Check to see if *LIST contains any element other than C. */
79 for (p
= *list
; p
!= NULL
; p
= p
->next
)
85 /* *SET_LIST only contains SET. */
86 p
= lookup_cmd_for_prefixlist (list
, setlist
);
88 c
->prefix
= p
? (p
->cmd_pointer
? p
->cmd_pointer
: p
) : p
;
91 c
->prefix
= p
->prefix
;
95 print_help_for_command (struct cmd_list_element
*c
, const char *prefix
,
96 int recurse
, struct ui_file
*stream
);
99 /* Set the callback function for the specified command. For each both
100 the commands callback and func() are set. The latter set to a
101 bounce function (unless cfunc / sfunc is NULL that is). */
104 do_cfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
106 c
->function
.cfunc (args
, from_tty
); /* Ok. */
110 set_cmd_cfunc (struct cmd_list_element
*cmd
, cmd_cfunc_ftype
*cfunc
)
115 cmd
->func
= do_cfunc
;
116 cmd
->function
.cfunc
= cfunc
; /* Ok. */
120 do_sfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
122 c
->function
.sfunc (args
, from_tty
, c
); /* Ok. */
126 set_cmd_sfunc (struct cmd_list_element
*cmd
, cmd_sfunc_ftype
*sfunc
)
131 cmd
->func
= do_sfunc
;
132 cmd
->function
.sfunc
= sfunc
; /* Ok. */
136 cmd_cfunc_eq (struct cmd_list_element
*cmd
, cmd_cfunc_ftype
*cfunc
)
138 return cmd
->func
== do_cfunc
&& cmd
->function
.cfunc
== cfunc
;
142 set_cmd_context (struct cmd_list_element
*cmd
, void *context
)
144 cmd
->context
= context
;
148 get_cmd_context (struct cmd_list_element
*cmd
)
154 cmd_type (struct cmd_list_element
*cmd
)
160 set_cmd_completer (struct cmd_list_element
*cmd
, completer_ftype
*completer
)
162 cmd
->completer
= completer
; /* Ok. */
165 /* See definition in commands.h. */
168 set_cmd_completer_handle_brkchars (struct cmd_list_element
*cmd
,
169 completer_ftype_void
*completer_handle_brkchars
)
171 cmd
->completer_handle_brkchars
= completer_handle_brkchars
;
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 (const char *name
, enum command_class theclass
, cmd_cfunc_ftype
*fun
,
194 const char *doc
, struct cmd_list_element
**list
)
196 struct cmd_list_element
*c
= XNEW (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)
231 c
->theclass
= theclass
;
232 set_cmd_cfunc (c
, fun
);
233 set_cmd_context (c
, NULL
);
235 c
->cmd_deprecated
= 0;
236 c
->deprecated_warn_user
= 0;
237 c
->malloced_replacement
= 0;
238 c
->doc_allocated
= 0;
239 c
->replacement
= NULL
;
240 c
->pre_show_hook
= NULL
;
242 c
->prefixlist
= NULL
;
243 c
->prefixname
= NULL
;
244 c
->allow_unknown
= 0;
247 set_cmd_completer (c
, make_symbol_completion_list_fn
);
248 c
->completer_handle_brkchars
= NULL
;
250 c
->type
= not_set_cmd
;
252 c
->var_type
= var_boolean
;
254 c
->user_commands
= NULL
;
255 c
->cmd_pointer
= NULL
;
256 c
->alias_chain
= NULL
;
257 c
->suppress_notification
= NULL
;
262 /* Deprecates a command CMD.
263 REPLACEMENT is the name of the command which should be used in
264 place of this command, or NULL if no such command exists.
266 This function does not check to see if command REPLACEMENT exists
267 since gdb may not have gotten around to adding REPLACEMENT when
268 this function is called.
270 Returns a pointer to the deprecated command. */
272 struct cmd_list_element
*
273 deprecate_cmd (struct cmd_list_element
*cmd
, const char *replacement
)
275 cmd
->cmd_deprecated
= 1;
276 cmd
->deprecated_warn_user
= 1;
278 if (replacement
!= NULL
)
279 cmd
->replacement
= replacement
;
281 cmd
->replacement
= NULL
;
286 struct cmd_list_element
*
287 add_alias_cmd (const char *name
, cmd_list_element
*old
,
288 enum command_class theclass
, int abbrev_flag
,
289 struct cmd_list_element
**list
)
293 struct cmd_list_element
*prehook
, *prehookee
, *posthook
, *posthookee
;
294 struct cmd_list_element
*aliases
= delete_cmd (name
, list
,
295 &prehook
, &prehookee
,
296 &posthook
, &posthookee
);
298 /* If this happens, it means a programmer error somewhere. */
299 gdb_assert (!aliases
&& !prehook
&& !prehookee
300 && !posthook
&& ! posthookee
);
304 struct cmd_list_element
*c
= add_cmd (name
, theclass
, NULL
, old
->doc
, list
);
306 /* If OLD->DOC can be freed, we should make another copy. */
307 if (old
->doc_allocated
)
309 c
->doc
= xstrdup (old
->doc
);
310 c
->doc_allocated
= 1;
312 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
314 c
->function
= old
->function
;
315 c
->prefixlist
= old
->prefixlist
;
316 c
->prefixname
= old
->prefixname
;
317 c
->allow_unknown
= old
->allow_unknown
;
318 c
->abbrev_flag
= abbrev_flag
;
319 c
->cmd_pointer
= old
;
320 c
->alias_chain
= old
->aliases
;
323 set_cmd_prefix (c
, list
);
327 struct cmd_list_element
*
328 add_alias_cmd (const char *name
, const char *oldname
,
329 enum command_class theclass
, int abbrev_flag
,
330 struct cmd_list_element
**list
)
333 struct cmd_list_element
*old
;
336 old
= lookup_cmd (&tmp
, *list
, "", 1, 1);
338 return add_alias_cmd (name
, old
, theclass
, abbrev_flag
, list
);
342 /* Like add_cmd but adds an element for a command prefix: a name that
343 should be followed by a subcommand to be looked up in another
344 command list. PREFIXLIST should be the address of the variable
345 containing that list. */
347 struct cmd_list_element
*
348 add_prefix_cmd (const char *name
, enum command_class theclass
,
349 cmd_cfunc_ftype
*fun
,
350 const char *doc
, struct cmd_list_element
**prefixlist
,
351 const char *prefixname
, int allow_unknown
,
352 struct cmd_list_element
**list
)
354 struct cmd_list_element
*c
= add_cmd (name
, theclass
, fun
, doc
, list
);
355 struct cmd_list_element
*p
;
357 c
->prefixlist
= prefixlist
;
358 c
->prefixname
= prefixname
;
359 c
->allow_unknown
= allow_unknown
;
361 if (list
== &cmdlist
)
364 set_cmd_prefix (c
, list
);
366 /* Update the field 'prefix' of each cmd_list_element in *PREFIXLIST. */
367 for (p
= *prefixlist
; p
!= NULL
; p
= p
->next
)
373 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
375 struct cmd_list_element
*
376 add_abbrev_prefix_cmd (const char *name
, enum command_class theclass
,
377 cmd_cfunc_ftype
*fun
, const char *doc
,
378 struct cmd_list_element
**prefixlist
,
379 const char *prefixname
,
380 int allow_unknown
, struct cmd_list_element
**list
)
382 struct cmd_list_element
*c
= add_cmd (name
, theclass
, fun
, doc
, list
);
384 c
->prefixlist
= prefixlist
;
385 c
->prefixname
= prefixname
;
386 c
->allow_unknown
= allow_unknown
;
391 /* This is an empty "cfunc". */
393 not_just_help_class_command (char *args
, int from_tty
)
397 /* This is an empty "sfunc". */
398 static void empty_sfunc (char *, int, struct cmd_list_element
*);
401 empty_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
405 /* Add element named NAME to command list LIST (the list for set/show
406 or some sublist thereof).
407 TYPE is set_cmd or show_cmd.
408 CLASS is as in add_cmd.
409 VAR_TYPE is the kind of thing we are setting.
410 VAR is address of the variable being controlled by this command.
411 DOC is the documentation string. */
413 static struct cmd_list_element
*
414 add_set_or_show_cmd (const char *name
,
416 enum command_class theclass
,
420 struct cmd_list_element
**list
)
422 struct cmd_list_element
*c
= add_cmd (name
, theclass
, NULL
, doc
, list
);
424 gdb_assert (type
== set_cmd
|| type
== show_cmd
);
426 c
->var_type
= var_type
;
428 /* This needs to be something besides NULL so that this isn't
429 treated as a help class. */
430 set_cmd_sfunc (c
, empty_sfunc
);
434 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
435 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
436 setting. VAR is address of the variable being controlled by this
437 command. SET_FUNC and SHOW_FUNC are the callback functions (if
438 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
439 strings. PRINT the format string to print the value. SET_RESULT
440 and SHOW_RESULT, if not NULL, are set to the resulting command
444 add_setshow_cmd_full (const char *name
,
445 enum command_class theclass
,
446 var_types var_type
, void *var
,
447 const char *set_doc
, const char *show_doc
,
448 const char *help_doc
,
449 cmd_sfunc_ftype
*set_func
,
450 show_value_ftype
*show_func
,
451 struct cmd_list_element
**set_list
,
452 struct cmd_list_element
**show_list
,
453 struct cmd_list_element
**set_result
,
454 struct cmd_list_element
**show_result
)
456 struct cmd_list_element
*set
;
457 struct cmd_list_element
*show
;
461 if (help_doc
!= NULL
)
463 full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
464 full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
468 full_set_doc
= xstrdup (set_doc
);
469 full_show_doc
= xstrdup (show_doc
);
471 set
= add_set_or_show_cmd (name
, set_cmd
, theclass
, var_type
, var
,
472 full_set_doc
, set_list
);
473 set
->doc_allocated
= 1;
475 if (set_func
!= NULL
)
476 set_cmd_sfunc (set
, set_func
);
478 set_cmd_prefix (set
, set_list
);
480 show
= add_set_or_show_cmd (name
, show_cmd
, theclass
, var_type
, var
,
481 full_show_doc
, show_list
);
482 show
->doc_allocated
= 1;
483 show
->show_value_func
= show_func
;
485 if (set_result
!= NULL
)
487 if (show_result
!= NULL
)
491 /* Add element named NAME to command list LIST (the list for set or
492 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
493 of strings which may follow NAME. VAR is address of the variable
494 which will contain the matching string (from ENUMLIST). */
497 add_setshow_enum_cmd (const char *name
,
498 enum command_class theclass
,
499 const char *const *enumlist
,
502 const char *show_doc
,
503 const char *help_doc
,
504 cmd_sfunc_ftype
*set_func
,
505 show_value_ftype
*show_func
,
506 struct cmd_list_element
**set_list
,
507 struct cmd_list_element
**show_list
)
509 struct cmd_list_element
*c
;
511 add_setshow_cmd_full (name
, theclass
, var_enum
, var
,
512 set_doc
, show_doc
, help_doc
,
519 const char * const auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
521 /* Add an auto-boolean command named NAME to both the set and show
522 command list lists. CLASS is as in add_cmd. VAR is address of the
523 variable which will contain the value. DOC is the documentation
524 string. FUNC is the corresponding callback. */
526 add_setshow_auto_boolean_cmd (const char *name
,
527 enum command_class theclass
,
528 enum auto_boolean
*var
,
529 const char *set_doc
, const char *show_doc
,
530 const char *help_doc
,
531 cmd_sfunc_ftype
*set_func
,
532 show_value_ftype
*show_func
,
533 struct cmd_list_element
**set_list
,
534 struct cmd_list_element
**show_list
)
536 struct cmd_list_element
*c
;
538 add_setshow_cmd_full (name
, theclass
, var_auto_boolean
, var
,
539 set_doc
, show_doc
, help_doc
,
543 c
->enums
= auto_boolean_enums
;
546 /* Add element named NAME to both the set and show command LISTs (the
547 list for set/show or some sublist thereof). CLASS is as in
548 add_cmd. VAR is address of the variable which will contain the
549 value. SET_DOC and SHOW_DOC are the documentation strings. */
551 add_setshow_boolean_cmd (const char *name
, enum command_class theclass
, int *var
,
552 const char *set_doc
, const char *show_doc
,
553 const char *help_doc
,
554 cmd_sfunc_ftype
*set_func
,
555 show_value_ftype
*show_func
,
556 struct cmd_list_element
**set_list
,
557 struct cmd_list_element
**show_list
)
559 static const char *boolean_enums
[] = { "on", "off", NULL
};
560 struct cmd_list_element
*c
;
562 add_setshow_cmd_full (name
, theclass
, var_boolean
, var
,
563 set_doc
, show_doc
, help_doc
,
567 c
->enums
= boolean_enums
;
570 /* Add element named NAME to both the set and show command LISTs (the
571 list for set/show or some sublist thereof). */
573 add_setshow_filename_cmd (const char *name
, enum command_class theclass
,
575 const char *set_doc
, const char *show_doc
,
576 const char *help_doc
,
577 cmd_sfunc_ftype
*set_func
,
578 show_value_ftype
*show_func
,
579 struct cmd_list_element
**set_list
,
580 struct cmd_list_element
**show_list
)
582 struct cmd_list_element
*set_result
;
584 add_setshow_cmd_full (name
, theclass
, var_filename
, var
,
585 set_doc
, show_doc
, help_doc
,
589 set_cmd_completer (set_result
, filename_completer
);
592 /* Add element named NAME to both the set and show command LISTs (the
593 list for set/show or some sublist thereof). */
595 add_setshow_string_cmd (const char *name
, enum command_class theclass
,
597 const char *set_doc
, const char *show_doc
,
598 const char *help_doc
,
599 cmd_sfunc_ftype
*set_func
,
600 show_value_ftype
*show_func
,
601 struct cmd_list_element
**set_list
,
602 struct cmd_list_element
**show_list
)
604 add_setshow_cmd_full (name
, theclass
, var_string
, var
,
605 set_doc
, show_doc
, help_doc
,
611 /* Add element named NAME to both the set and show command LISTs (the
612 list for set/show or some sublist thereof). */
613 struct cmd_list_element
*
614 add_setshow_string_noescape_cmd (const char *name
, enum command_class theclass
,
616 const char *set_doc
, const char *show_doc
,
617 const char *help_doc
,
618 cmd_sfunc_ftype
*set_func
,
619 show_value_ftype
*show_func
,
620 struct cmd_list_element
**set_list
,
621 struct cmd_list_element
**show_list
)
623 struct cmd_list_element
*set_cmd
;
625 add_setshow_cmd_full (name
, theclass
, var_string_noescape
, var
,
626 set_doc
, show_doc
, help_doc
,
633 /* Add element named NAME to both the set and show command LISTs (the
634 list for set/show or some sublist thereof). */
636 add_setshow_optional_filename_cmd (const char *name
, enum command_class theclass
,
638 const char *set_doc
, const char *show_doc
,
639 const char *help_doc
,
640 cmd_sfunc_ftype
*set_func
,
641 show_value_ftype
*show_func
,
642 struct cmd_list_element
**set_list
,
643 struct cmd_list_element
**show_list
)
645 struct cmd_list_element
*set_result
;
647 add_setshow_cmd_full (name
, theclass
, var_optional_filename
, var
,
648 set_doc
, show_doc
, help_doc
,
653 set_cmd_completer (set_result
, filename_completer
);
657 /* Completes on literal "unlimited". Used by integer commands that
658 support a special "unlimited" value. */
660 static VEC (char_ptr
) *
661 integer_unlimited_completer (struct cmd_list_element
*ignore
,
662 const char *text
, const char *word
)
664 static const char * const keywords
[] =
670 return complete_on_enum (keywords
, text
, word
);
673 /* Add element named NAME to both the set and show command LISTs (the
674 list for set/show or some sublist thereof). CLASS is as in
675 add_cmd. VAR is address of the variable which will contain the
676 value. SET_DOC and SHOW_DOC are the documentation strings. This
677 function is only used in Python API. Please don't use it elsewhere. */
679 add_setshow_integer_cmd (const char *name
, enum command_class theclass
,
681 const char *set_doc
, const char *show_doc
,
682 const char *help_doc
,
683 cmd_sfunc_ftype
*set_func
,
684 show_value_ftype
*show_func
,
685 struct cmd_list_element
**set_list
,
686 struct cmd_list_element
**show_list
)
688 struct cmd_list_element
*set
;
690 add_setshow_cmd_full (name
, theclass
, var_integer
, var
,
691 set_doc
, show_doc
, help_doc
,
696 set_cmd_completer (set
, integer_unlimited_completer
);
699 /* Add element named NAME to both the set and show command LISTs (the
700 list for set/show or some sublist thereof). CLASS is as in
701 add_cmd. VAR is address of the variable which will contain the
702 value. SET_DOC and SHOW_DOC are the documentation strings. */
704 add_setshow_uinteger_cmd (const char *name
, enum command_class theclass
,
706 const char *set_doc
, const char *show_doc
,
707 const char *help_doc
,
708 cmd_sfunc_ftype
*set_func
,
709 show_value_ftype
*show_func
,
710 struct cmd_list_element
**set_list
,
711 struct cmd_list_element
**show_list
)
713 struct cmd_list_element
*set
;
715 add_setshow_cmd_full (name
, theclass
, var_uinteger
, var
,
716 set_doc
, show_doc
, help_doc
,
721 set_cmd_completer (set
, integer_unlimited_completer
);
724 /* Add element named NAME to both the set and show command LISTs (the
725 list for set/show or some sublist thereof). CLASS is as in
726 add_cmd. VAR is address of the variable which will contain the
727 value. SET_DOC and SHOW_DOC are the documentation strings. */
729 add_setshow_zinteger_cmd (const char *name
, enum command_class theclass
,
731 const char *set_doc
, const char *show_doc
,
732 const char *help_doc
,
733 cmd_sfunc_ftype
*set_func
,
734 show_value_ftype
*show_func
,
735 struct cmd_list_element
**set_list
,
736 struct cmd_list_element
**show_list
)
738 add_setshow_cmd_full (name
, theclass
, var_zinteger
, var
,
739 set_doc
, show_doc
, help_doc
,
746 add_setshow_zuinteger_unlimited_cmd (const char *name
,
747 enum command_class theclass
,
750 const char *show_doc
,
751 const char *help_doc
,
752 cmd_sfunc_ftype
*set_func
,
753 show_value_ftype
*show_func
,
754 struct cmd_list_element
**set_list
,
755 struct cmd_list_element
**show_list
)
757 struct cmd_list_element
*set
;
759 add_setshow_cmd_full (name
, theclass
, var_zuinteger_unlimited
, var
,
760 set_doc
, show_doc
, help_doc
,
765 set_cmd_completer (set
, integer_unlimited_completer
);
768 /* Add element named NAME to both the set and show command LISTs (the
769 list for set/show or some sublist thereof). CLASS is as in
770 add_cmd. VAR is address of the variable which will contain the
771 value. SET_DOC and SHOW_DOC are the documentation strings. */
773 add_setshow_zuinteger_cmd (const char *name
, enum command_class theclass
,
775 const char *set_doc
, const char *show_doc
,
776 const char *help_doc
,
777 cmd_sfunc_ftype
*set_func
,
778 show_value_ftype
*show_func
,
779 struct cmd_list_element
**set_list
,
780 struct cmd_list_element
**show_list
)
782 add_setshow_cmd_full (name
, theclass
, var_zuinteger
, var
,
783 set_doc
, show_doc
, help_doc
,
789 /* Remove the command named NAME from the command list. Return the
790 list commands which were aliased to the deleted command. If the
791 command had no aliases, return NULL. The various *HOOKs are set to
792 the pre- and post-hook commands for the deleted command. If the
793 command does not have a hook, the corresponding out parameter is
796 static struct cmd_list_element
*
797 delete_cmd (const char *name
, struct cmd_list_element
**list
,
798 struct cmd_list_element
**prehook
,
799 struct cmd_list_element
**prehookee
,
800 struct cmd_list_element
**posthook
,
801 struct cmd_list_element
**posthookee
)
803 struct cmd_list_element
*iter
;
804 struct cmd_list_element
**previous_chain_ptr
;
805 struct cmd_list_element
*aliases
= NULL
;
811 previous_chain_ptr
= list
;
813 for (iter
= *previous_chain_ptr
; iter
; iter
= *previous_chain_ptr
)
815 if (strcmp (iter
->name
, name
) == 0)
818 iter
->destroyer (iter
, iter
->context
);
819 if (iter
->hookee_pre
)
820 iter
->hookee_pre
->hook_pre
= 0;
821 *prehook
= iter
->hook_pre
;
822 *prehookee
= iter
->hookee_pre
;
823 if (iter
->hookee_post
)
824 iter
->hookee_post
->hook_post
= 0;
825 if (iter
->doc
&& iter
->doc_allocated
)
826 xfree ((char *) iter
->doc
);
827 *posthook
= iter
->hook_post
;
828 *posthookee
= iter
->hookee_post
;
830 /* Update the link. */
831 *previous_chain_ptr
= iter
->next
;
833 aliases
= iter
->aliases
;
835 /* If this command was an alias, remove it from the list of
837 if (iter
->cmd_pointer
)
839 struct cmd_list_element
**prevp
= &iter
->cmd_pointer
->aliases
;
840 struct cmd_list_element
*a
= *prevp
;
844 prevp
= &a
->alias_chain
;
847 *prevp
= iter
->alias_chain
;
852 /* We won't see another command with the same name. */
856 previous_chain_ptr
= &iter
->next
;
862 /* Shorthands to the commands above. */
864 /* Add an element to the list of info subcommands. */
866 struct cmd_list_element
*
867 add_info (const char *name
, cmd_cfunc_ftype
*fun
, const char *doc
)
869 return add_cmd (name
, class_info
, fun
, doc
, &infolist
);
872 /* Add an alias to the list of info subcommands. */
874 struct cmd_list_element
*
875 add_info_alias (const char *name
, const char *oldname
, int abbrev_flag
)
877 return add_alias_cmd (name
, oldname
, class_run
, abbrev_flag
, &infolist
);
880 /* Add an element to the list of commands. */
882 struct cmd_list_element
*
883 add_com (const char *name
, enum command_class theclass
, cmd_cfunc_ftype
*fun
,
886 return add_cmd (name
, theclass
, fun
, doc
, &cmdlist
);
889 /* Add an alias or abbreviation command to the list of commands. */
891 struct cmd_list_element
*
892 add_com_alias (const char *name
, const char *oldname
, enum command_class theclass
,
895 return add_alias_cmd (name
, oldname
, theclass
, abbrev_flag
, &cmdlist
);
898 /* Add an element with a suppress notification to the list of commands. */
900 struct cmd_list_element
*
901 add_com_suppress_notification (const char *name
, enum command_class theclass
,
902 cmd_cfunc_ftype
*fun
, const char *doc
,
903 int *suppress_notification
)
905 struct cmd_list_element
*element
;
907 element
= add_cmd (name
, theclass
, fun
, doc
, &cmdlist
);
908 element
->suppress_notification
= suppress_notification
;
913 /* Recursively walk the commandlist structures, and print out the
914 documentation of commands that match our regex in either their
915 name, or their documentation.
918 apropos_cmd (struct ui_file
*stream
,
919 struct cmd_list_element
*commandlist
,
920 struct re_pattern_buffer
*regex
, const char *prefix
)
922 struct cmd_list_element
*c
;
925 /* Walk through the commands. */
926 for (c
=commandlist
;c
;c
=c
->next
)
928 returnvalue
= -1; /* Needed to avoid double printing. */
931 /* Try to match against the name. */
932 returnvalue
= re_search (regex
, c
->name
, strlen(c
->name
),
933 0, strlen (c
->name
), NULL
);
934 if (returnvalue
>= 0)
936 print_help_for_command (c
, prefix
,
937 0 /* don't recurse */, stream
);
940 if (c
->doc
!= NULL
&& returnvalue
< 0)
942 /* Try to match against documentation. */
943 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
945 print_help_for_command (c
, prefix
,
946 0 /* don't recurse */, stream
);
949 /* Check if this command has subcommands and is not an
950 abbreviation. We skip listing subcommands of abbreviations
951 in order to avoid duplicates in the output. */
952 if (c
->prefixlist
!= NULL
&& !c
->abbrev_flag
)
954 /* Recursively call ourselves on the subcommand list,
955 passing the right prefix in. */
956 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
961 /* This command really has to deal with two things:
962 1) I want documentation on *this string* (usually called by
965 2) I want documentation on *this list* (usually called by giving a
966 command that requires subcommands. Also called by saying just
969 I am going to split this into two seperate comamnds, help_cmd and
973 help_cmd (const char *command
, struct ui_file
*stream
)
975 struct cmd_list_element
*c
;
979 help_list (cmdlist
, "", all_classes
, stream
);
983 if (strcmp (command
, "all") == 0)
989 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
994 /* There are three cases here.
995 If c->prefixlist is nonzero, we have a prefix command.
996 Print its documentation, then list its subcommands.
998 If c->func is non NULL, we really have a command. Print its
999 documentation and return.
1001 If c->func is NULL, we have a class name. Print its
1002 documentation (as if it were a command) and then set class to the
1003 number of this class so that the commands in the class will be
1006 fputs_filtered (c
->doc
, stream
);
1007 fputs_filtered ("\n", stream
);
1009 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
1011 fprintf_filtered (stream
, "\n");
1013 /* If this is a prefix command, print it's subcommands. */
1015 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
1017 /* If this is a class name, print all of the commands in the class. */
1018 if (c
->func
== NULL
)
1019 help_list (cmdlist
, "", c
->theclass
, stream
);
1021 if (c
->hook_pre
|| c
->hook_post
)
1022 fprintf_filtered (stream
,
1023 "\nThis command has a hook (or hooks) defined:\n");
1026 fprintf_filtered (stream
,
1027 "\tThis command is run after : %s (pre hook)\n",
1030 fprintf_filtered (stream
,
1031 "\tThis command is run before : %s (post hook)\n",
1032 c
->hook_post
->name
);
1036 * Get a specific kind of help on a command list.
1039 * CMDTYPE is the prefix to use in the title string.
1040 * CLASS is the class with which to list the nodes of this list (see
1041 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
1042 * everything, ALL_CLASSES for just classes, and non-negative for only things
1043 * in a specific class.
1044 * and STREAM is the output stream on which to print things.
1045 * If you call this routine with a class >= 0, it recurses.
1048 help_list (struct cmd_list_element
*list
, const char *cmdtype
,
1049 enum command_class theclass
, struct ui_file
*stream
)
1052 char *cmdtype1
, *cmdtype2
;
1054 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
1056 len
= strlen (cmdtype
);
1057 cmdtype1
= (char *) alloca (len
+ 1);
1059 cmdtype2
= (char *) alloca (len
+ 4);
1064 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
1066 strncpy (cmdtype2
, cmdtype
, len
- 1);
1067 strcpy (cmdtype2
+ len
- 1, " sub");
1070 if (theclass
== all_classes
)
1071 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
1073 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
1075 help_cmd_list (list
, theclass
, cmdtype
, (int) theclass
>= 0, stream
);
1077 if (theclass
== all_classes
)
1079 fprintf_filtered (stream
, "\n\
1080 Type \"help%s\" followed by a class name for a list of commands in ",
1083 fprintf_filtered (stream
, "that class.");
1085 fprintf_filtered (stream
, "\n\
1086 Type \"help all\" for the list of all commands.");
1089 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
1090 cmdtype1
, cmdtype2
);
1092 fputs_filtered ("for ", stream
);
1094 fputs_filtered ("full ", stream
);
1096 fputs_filtered ("documentation.\n", stream
);
1097 fputs_filtered ("Type \"apropos word\" to search "
1098 "for commands related to \"word\".\n", stream
);
1099 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
1104 help_all (struct ui_file
*stream
)
1106 struct cmd_list_element
*c
;
1107 int seen_unclassified
= 0;
1109 for (c
= cmdlist
; c
; c
= c
->next
)
1113 /* If this is a class name, print all of the commands in the
1116 if (c
->func
== NULL
)
1118 fprintf_filtered (stream
, "\nCommand class: %s\n\n", c
->name
);
1119 help_cmd_list (cmdlist
, c
->theclass
, "", 1, stream
);
1123 /* While it's expected that all commands are in some class,
1124 as a safety measure, we'll print commands outside of any
1125 class at the end. */
1127 for (c
= cmdlist
; c
; c
= c
->next
)
1132 if (c
->theclass
== no_class
)
1134 if (!seen_unclassified
)
1136 fprintf_filtered (stream
, "\nUnclassified commands\n\n");
1137 seen_unclassified
= 1;
1139 print_help_for_command (c
, "", 1, stream
);
1145 /* Print only the first line of STR on STREAM. */
1147 print_doc_line (struct ui_file
*stream
, const char *str
)
1149 static char *line_buffer
= 0;
1150 static int line_size
;
1156 line_buffer
= (char *) xmalloc (line_size
);
1159 /* Keep printing '.' or ',' not followed by a whitespace for embedded strings
1162 while (*p
&& *p
!= '\n'
1163 && ((*p
!= '.' && *p
!= ',') || (p
[1] && !isspace (p
[1]))))
1165 if (p
- str
> line_size
- 1)
1167 line_size
= p
- str
+ 1;
1168 xfree (line_buffer
);
1169 line_buffer
= (char *) xmalloc (line_size
);
1171 strncpy (line_buffer
, str
, p
- str
);
1172 line_buffer
[p
- str
] = '\0';
1173 if (islower (line_buffer
[0]))
1174 line_buffer
[0] = toupper (line_buffer
[0]);
1175 fputs_filtered (line_buffer
, stream
);
1178 /* Print one-line help for command C.
1179 If RECURSE is non-zero, also print one-line descriptions
1180 of all prefixed subcommands. */
1182 print_help_for_command (struct cmd_list_element
*c
, const char *prefix
,
1183 int recurse
, struct ui_file
*stream
)
1185 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
1186 print_doc_line (stream
, c
->doc
);
1187 fputs_filtered ("\n", stream
);
1190 && c
->prefixlist
!= 0
1191 && c
->abbrev_flag
== 0)
1192 /* Subcommands of a prefix command typically have 'all_commands'
1193 as class. If we pass CLASS to recursive invocation,
1194 most often we won't see anything. */
1195 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 1, stream
);
1199 * Implement a help command on command list LIST.
1200 * RECURSE should be non-zero if this should be done recursively on
1201 * all sublists of LIST.
1202 * PREFIX is the prefix to print before each command name.
1203 * STREAM is the stream upon which the output should be written.
1204 * THECLASS should be:
1205 * A non-negative class number to list only commands in that
1207 * ALL_COMMANDS to list all commands in list.
1208 * ALL_CLASSES to list all classes in list.
1210 * Note that RECURSE will be active on *all* sublists, not just the
1211 * ones selected by the criteria above (ie. the selection mechanism
1212 * is at the low level, not the high-level).
1215 help_cmd_list (struct cmd_list_element
*list
, enum command_class theclass
,
1216 const char *prefix
, int recurse
, struct ui_file
*stream
)
1218 struct cmd_list_element
*c
;
1220 for (c
= list
; c
; c
= c
->next
)
1222 if (c
->abbrev_flag
== 0
1223 && !c
->cmd_deprecated
1224 && (theclass
== all_commands
1225 || (theclass
== all_classes
&& c
->func
== NULL
)
1226 || (theclass
== c
->theclass
&& c
->func
!= NULL
)))
1228 print_help_for_command (c
, prefix
, recurse
, stream
);
1230 else if (c
->abbrev_flag
== 0
1232 && !c
->cmd_deprecated
1233 && theclass
== class_user
&& c
->prefixlist
!= NULL
)
1234 /* User-defined commands may be subcommands. */
1235 help_cmd_list (*c
->prefixlist
, theclass
, c
->prefixname
,
1241 /* Search the input clist for 'command'. Return the command if
1242 found (or NULL if not), and return the number of commands
1245 static struct cmd_list_element
*
1246 find_cmd (const char *command
, int len
, struct cmd_list_element
*clist
,
1247 int ignore_help_classes
, int *nfound
)
1249 struct cmd_list_element
*found
, *c
;
1253 for (c
= clist
; c
; c
= c
->next
)
1254 if (!strncmp (command
, c
->name
, len
)
1255 && (!ignore_help_classes
|| c
->func
))
1259 if (c
->name
[len
] == '\0')
1268 /* Return the length of command name in TEXT. */
1271 find_command_name_length (const char *text
)
1273 const char *p
= text
;
1275 /* Treating underscores as part of command words is important
1276 so that "set args_foo()" doesn't get interpreted as
1277 "set args _foo()". */
1278 /* Some characters are only used for TUI specific commands.
1279 However, they are always allowed for the sake of consistency.
1281 Note that this is larger than the character set allowed when
1282 creating user-defined commands. */
1284 /* Recognize '!' as a single character command so that, e.g., "!ls"
1285 works as expected. */
1289 while (isalnum (*p
) || *p
== '-' || *p
== '_'
1290 /* Characters used by TUI specific commands. */
1291 || *p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')
1297 /* Return TRUE if NAME is a valid user-defined command name.
1298 This is a stricter subset of all gdb commands,
1299 see find_command_name_length. */
1302 valid_user_defined_cmd_name_p (const char *name
)
1309 /* Alas "42" is a legitimate user-defined command.
1310 In the interests of not breaking anything we preserve that. */
1312 for (p
= name
; *p
!= '\0'; ++p
)
1325 /* This routine takes a line of TEXT and a CLIST in which to start the
1326 lookup. When it returns it will have incremented the text pointer past
1327 the section of text it matched, set *RESULT_LIST to point to the list in
1328 which the last word was matched, and will return a pointer to the cmd
1329 list element which the text matches. It will return NULL if no match at
1330 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1331 matches are possible; in this case *RESULT_LIST will be set to point to
1332 the list in which there are ambiguous choices (and *TEXT will be set to
1333 the ambiguous text string).
1335 If the located command was an abbreviation, this routine returns the base
1336 command of the abbreviation.
1338 It does no error reporting whatsoever; control will always return
1339 to the superior routine.
1341 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1342 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1343 if no prefix command was ever found. For example, in the case of "info a",
1344 "info" matches without ambiguity, but "a" could be "args" or "address", so
1345 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1346 RESULT_LIST should not be interpreted as a pointer to the beginning of a
1347 list; it simply points to a specific command. In the case of an ambiguous
1348 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1349 "info t" can be "info types" or "info target"; upon return *TEXT has been
1350 advanced past "info ").
1352 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1353 affect the operation).
1355 This routine does *not* modify the text pointed to by TEXT.
1357 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1358 are actually help classes rather than commands (i.e. the function field of
1359 the struct cmd_list_element is NULL). */
1361 struct cmd_list_element
*
1362 lookup_cmd_1 (const char **text
, struct cmd_list_element
*clist
,
1363 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1366 int len
, tmp
, nfound
;
1367 struct cmd_list_element
*found
, *c
;
1368 const char *line
= *text
;
1370 while (**text
== ' ' || **text
== '\t')
1373 /* Identify the name of the command. */
1374 len
= find_command_name_length (*text
);
1376 /* If nothing but whitespace, return 0. */
1380 /* *text and p now bracket the first command word to lookup (and
1381 it's length is len). We copy this into a local temporary. */
1384 command
= (char *) alloca (len
+ 1);
1385 memcpy (command
, *text
, len
);
1386 command
[len
] = '\0';
1391 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1393 /* If nothing matches, we have a simple failure. */
1399 if (result_list
!= NULL
)
1400 /* Will be modified in calling routine
1401 if we know what the prefix command is. */
1403 return CMD_LIST_AMBIGUOUS
; /* Ambiguous. */
1406 /* We've matched something on this list. Move text pointer forward. */
1410 if (found
->cmd_pointer
)
1412 /* We drop the alias (abbreviation) in favor of the command it
1413 is pointing to. If the alias is deprecated, though, we need to
1414 warn the user about it before we drop it. Note that while we
1415 are warning about the alias, we may also warn about the command
1416 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1419 if (found
->deprecated_warn_user
)
1420 deprecated_cmd_warning (line
);
1421 found
= found
->cmd_pointer
;
1423 /* If we found a prefix command, keep looking. */
1425 if (found
->prefixlist
)
1427 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1428 ignore_help_classes
);
1431 /* Didn't find anything; this is as far as we got. */
1432 if (result_list
!= NULL
)
1433 *result_list
= clist
;
1436 else if (c
== CMD_LIST_AMBIGUOUS
)
1438 /* We've gotten this far properly, but the next step is
1439 ambiguous. We need to set the result list to the best
1440 we've found (if an inferior hasn't already set it). */
1441 if (result_list
!= NULL
)
1443 /* This used to say *result_list = *found->prefixlist.
1444 If that was correct, need to modify the documentation
1445 at the top of this function to clarify what is
1446 supposed to be going on. */
1447 *result_list
= found
;
1458 if (result_list
!= NULL
)
1459 *result_list
= clist
;
1464 /* All this hair to move the space to the front of cmdtype */
1467 undef_cmd_error (const char *cmdtype
, const char *q
)
1469 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1472 *cmdtype
? " " : "",
1473 (int) strlen (cmdtype
) - 1,
1477 /* Look up the contents of *LINE as a command in the command list LIST.
1478 LIST is a chain of struct cmd_list_element's.
1479 If it is found, return the struct cmd_list_element for that command
1480 and update *LINE to point after the command name, at the first argument.
1481 If not found, call error if ALLOW_UNKNOWN is zero
1482 otherwise (or if error returns) return zero.
1483 Call error if specified command is ambiguous,
1484 unless ALLOW_UNKNOWN is negative.
1485 CMDTYPE precedes the word "command" in the error message.
1487 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1488 elements which are actually help classes rather than commands (i.e.
1489 the function field of the struct cmd_list_element is 0). */
1491 struct cmd_list_element
*
1492 lookup_cmd (const char **line
, struct cmd_list_element
*list
,
1493 const char *cmdtype
,
1494 int allow_unknown
, int ignore_help_classes
)
1496 struct cmd_list_element
*last_list
= 0;
1497 struct cmd_list_element
*c
;
1499 /* Note: Do not remove trailing whitespace here because this
1500 would be wrong for complete_command. Jim Kingdon */
1503 error (_("Lack of needed %scommand"), cmdtype
);
1505 c
= lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1512 int len
= find_command_name_length (*line
);
1514 q
= (char *) alloca (len
+ 1);
1515 strncpy (q
, *line
, len
);
1517 undef_cmd_error (cmdtype
, q
);
1522 else if (c
== CMD_LIST_AMBIGUOUS
)
1524 /* Ambigous. Local values should be off prefixlist or called
1526 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1528 const char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1529 struct cmd_list_element
*local_list
=
1530 (last_list
? *(last_list
->prefixlist
) : list
);
1532 if (local_allow_unknown
< 0)
1535 return last_list
; /* Found something. */
1537 return 0; /* Found nothing. */
1541 /* Report as error. */
1546 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1547 && (*line
)[amb_len
] != '\t');
1552 for (c
= local_list
; c
; c
= c
->next
)
1553 if (!strncmp (*line
, c
->name
, amb_len
))
1555 if (strlen (ambbuf
) + strlen (c
->name
) + 6
1556 < (int) sizeof ambbuf
)
1558 if (strlen (ambbuf
))
1559 strcat (ambbuf
, ", ");
1560 strcat (ambbuf
, c
->name
);
1564 strcat (ambbuf
, "..");
1568 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1570 return 0; /* lint */
1575 if (c
->type
== set_cmd
&& **line
!= '\0' && !isspace (**line
))
1576 error (_("Argument must be preceded by space."));
1578 /* We've got something. It may still not be what the caller
1579 wants (if this command *needs* a subcommand). */
1580 while (**line
== ' ' || **line
== '\t')
1583 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1584 undef_cmd_error (c
->prefixname
, *line
);
1586 /* Seems to be what he wants. Return it. */
1592 /* We are here presumably because an alias or command in TEXT is
1593 deprecated and a warning message should be generated. This
1594 function decodes TEXT and potentially generates a warning message
1597 Example for 'set endian big' which has a fictitious alias 'seb'.
1599 If alias wasn't used in TEXT, and the command is deprecated:
1600 "warning: 'set endian big' is deprecated."
1602 If alias was used, and only the alias is deprecated:
1603 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1605 If alias was used and command is deprecated (regardless of whether
1606 the alias itself is deprecated:
1608 "warning: 'set endian big' (seb) is deprecated."
1610 After the message has been sent, clear the appropriate flags in the
1611 command and/or the alias so the user is no longer bothered.
1615 deprecated_cmd_warning (const char *text
)
1617 struct cmd_list_element
*alias
= NULL
;
1618 struct cmd_list_element
*prefix_cmd
= NULL
;
1619 struct cmd_list_element
*cmd
= NULL
;
1621 if (!lookup_cmd_composition (text
, &alias
, &prefix_cmd
, &cmd
))
1622 /* Return if text doesn't evaluate to a command. */
1625 if (!((alias
? alias
->deprecated_warn_user
: 0)
1626 || cmd
->deprecated_warn_user
) )
1627 /* Return if nothing is deprecated. */
1630 printf_filtered ("Warning:");
1632 if (alias
&& !cmd
->cmd_deprecated
)
1633 printf_filtered (" '%s', an alias for the", alias
->name
);
1635 printf_filtered (" command '");
1638 printf_filtered ("%s", prefix_cmd
->prefixname
);
1640 printf_filtered ("%s", cmd
->name
);
1642 if (alias
&& cmd
->cmd_deprecated
)
1643 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1645 printf_filtered ("' is deprecated.\n");
1648 /* If it is only the alias that is deprecated, we want to indicate
1649 the new alias, otherwise we'll indicate the new command. */
1651 if (alias
&& !cmd
->cmd_deprecated
)
1653 if (alias
->replacement
)
1654 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1656 printf_filtered ("No alternative known.\n\n");
1660 if (cmd
->replacement
)
1661 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1663 printf_filtered ("No alternative known.\n\n");
1666 /* We've warned you, now we'll keep quiet. */
1668 alias
->deprecated_warn_user
= 0;
1670 cmd
->deprecated_warn_user
= 0;
1674 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1675 Return 1 on success, 0 on failure.
1677 If LINE refers to an alias, *alias will point to that alias.
1679 If LINE is a postfix command (i.e. one that is preceded by a prefix
1680 command) set *prefix_cmd.
1682 Set *cmd to point to the command LINE indicates.
1684 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1685 exist, they are NULL when we return.
1689 lookup_cmd_composition (const char *text
,
1690 struct cmd_list_element
**alias
,
1691 struct cmd_list_element
**prefix_cmd
,
1692 struct cmd_list_element
**cmd
)
1695 int len
, tmp
, nfound
;
1696 struct cmd_list_element
*cur_list
;
1697 struct cmd_list_element
*prev_cmd
;
1707 /* Go through as many command lists as we need to,
1708 to find the command TEXT refers to. */
1712 while (*text
== ' ' || *text
== '\t')
1715 /* Identify the name of the command. */
1716 len
= find_command_name_length (text
);
1718 /* If nothing but whitespace, return. */
1722 /* Text is the start of the first command word to lookup (and
1723 it's length is len). We copy this into a local temporary. */
1725 command
= (char *) alloca (len
+ 1);
1726 memcpy (command
, text
, len
);
1727 command
[len
] = '\0';
1732 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1734 if (*cmd
== CMD_LIST_AMBIGUOUS
)
1736 return 0; /* ambiguous */
1740 return 0; /* nothing found */
1743 if ((*cmd
)->cmd_pointer
)
1745 /* cmd was actually an alias, we note that an alias was
1746 used (by assigning *alais) and we set *cmd. */
1748 *cmd
= (*cmd
)->cmd_pointer
;
1750 *prefix_cmd
= prev_cmd
;
1752 if ((*cmd
)->prefixlist
)
1753 cur_list
= *(*cmd
)->prefixlist
;
1761 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1763 /* Return a vector of char pointers which point to the different
1764 possible completions in LIST of TEXT.
1766 WORD points in the same buffer as TEXT, and completions should be
1767 returned relative to this position. For example, suppose TEXT is
1768 "foo" and we want to complete to "foobar". If WORD is "oo", return
1769 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1772 complete_on_cmdlist (struct cmd_list_element
*list
,
1773 const char *text
, const char *word
,
1774 int ignore_help_classes
)
1776 struct cmd_list_element
*ptr
;
1777 VEC (char_ptr
) *matchlist
= NULL
;
1778 int textlen
= strlen (text
);
1780 int saw_deprecated_match
= 0;
1782 /* We do one or two passes. In the first pass, we skip deprecated
1783 commands. If we see no matching commands in the first pass, and
1784 if we did happen to see a matching deprecated command, we do
1785 another loop to collect those. */
1786 for (pass
= 0; matchlist
== 0 && pass
< 2; ++pass
)
1788 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1789 if (!strncmp (ptr
->name
, text
, textlen
)
1790 && !ptr
->abbrev_flag
1791 && (!ignore_help_classes
|| ptr
->func
1792 || ptr
->prefixlist
))
1798 if (ptr
->cmd_deprecated
)
1800 saw_deprecated_match
= 1;
1805 match
= (char *) xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1807 strcpy (match
, ptr
->name
);
1808 else if (word
> text
)
1810 /* Return some portion of ptr->name. */
1811 strcpy (match
, ptr
->name
+ (word
- text
));
1815 /* Return some of text plus ptr->name. */
1816 strncpy (match
, word
, text
- word
);
1817 match
[text
- word
] = '\0';
1818 strcat (match
, ptr
->name
);
1820 VEC_safe_push (char_ptr
, matchlist
, match
);
1822 /* If we saw no matching deprecated commands in the first pass,
1824 if (!saw_deprecated_match
)
1831 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1833 /* Return a vector of char pointers which point to the different
1834 possible completions in CMD of TEXT.
1836 WORD points in the same buffer as TEXT, and completions should be
1837 returned relative to this position. For example, suppose TEXT is "foo"
1838 and we want to complete to "foobar". If WORD is "oo", return
1839 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1842 complete_on_enum (const char *const *enumlist
,
1843 const char *text
, const char *word
)
1845 VEC (char_ptr
) *matchlist
= NULL
;
1846 int textlen
= strlen (text
);
1850 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1851 if (strncmp (name
, text
, textlen
) == 0)
1855 match
= (char *) xmalloc (strlen (word
) + strlen (name
) + 1);
1857 strcpy (match
, name
);
1858 else if (word
> text
)
1860 /* Return some portion of name. */
1861 strcpy (match
, name
+ (word
- text
));
1865 /* Return some of text plus name. */
1866 strncpy (match
, word
, text
- word
);
1867 match
[text
- word
] = '\0';
1868 strcat (match
, name
);
1870 VEC_safe_push (char_ptr
, matchlist
, match
);
1877 /* Check function pointer. */
1879 cmd_func_p (struct cmd_list_element
*cmd
)
1881 return (cmd
->func
!= NULL
);
1885 /* Call the command function. */
1887 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1889 if (cmd_func_p (cmd
))
1891 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1893 if (cmd
->suppress_notification
!= NULL
)
1894 restore_suppress
.emplace (cmd
->suppress_notification
, 1);
1896 (*cmd
->func
) (cmd
, args
, from_tty
);
1899 error (_("Invalid command"));
1903 cli_user_command_p (struct cmd_list_element
*cmd
)
1905 return (cmd
->theclass
== class_user
1906 && (cmd
->func
== do_cfunc
|| cmd
->func
== do_sfunc
));