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
, const char *oldname
, enum command_class theclass
,
288 int abbrev_flag
, struct cmd_list_element
**list
)
291 struct cmd_list_element
*old
;
292 struct cmd_list_element
*c
;
295 old
= lookup_cmd (&tmp
, *list
, "", 1, 1);
299 struct cmd_list_element
*prehook
, *prehookee
, *posthook
, *posthookee
;
300 struct cmd_list_element
*aliases
= delete_cmd (name
, list
,
301 &prehook
, &prehookee
,
302 &posthook
, &posthookee
);
304 /* If this happens, it means a programmer error somewhere. */
305 gdb_assert (!aliases
&& !prehook
&& !prehookee
306 && !posthook
&& ! posthookee
);
310 c
= add_cmd (name
, theclass
, NULL
, old
->doc
, list
);
312 /* If OLD->DOC can be freed, we should make another copy. */
313 if (old
->doc_allocated
)
315 c
->doc
= xstrdup (old
->doc
);
316 c
->doc_allocated
= 1;
318 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
320 c
->function
= old
->function
;
321 c
->prefixlist
= old
->prefixlist
;
322 c
->prefixname
= old
->prefixname
;
323 c
->allow_unknown
= old
->allow_unknown
;
324 c
->abbrev_flag
= abbrev_flag
;
325 c
->cmd_pointer
= old
;
326 c
->alias_chain
= old
->aliases
;
329 set_cmd_prefix (c
, list
);
333 /* Like add_cmd but adds an element for a command prefix: a name that
334 should be followed by a subcommand to be looked up in another
335 command list. PREFIXLIST should be the address of the variable
336 containing that list. */
338 struct cmd_list_element
*
339 add_prefix_cmd (const char *name
, enum command_class theclass
,
340 cmd_cfunc_ftype
*fun
,
341 const char *doc
, struct cmd_list_element
**prefixlist
,
342 const char *prefixname
, int allow_unknown
,
343 struct cmd_list_element
**list
)
345 struct cmd_list_element
*c
= add_cmd (name
, theclass
, fun
, doc
, list
);
346 struct cmd_list_element
*p
;
348 c
->prefixlist
= prefixlist
;
349 c
->prefixname
= prefixname
;
350 c
->allow_unknown
= allow_unknown
;
352 if (list
== &cmdlist
)
355 set_cmd_prefix (c
, list
);
357 /* Update the field 'prefix' of each cmd_list_element in *PREFIXLIST. */
358 for (p
= *prefixlist
; p
!= NULL
; p
= p
->next
)
364 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
366 struct cmd_list_element
*
367 add_abbrev_prefix_cmd (const char *name
, enum command_class theclass
,
368 cmd_cfunc_ftype
*fun
, const char *doc
,
369 struct cmd_list_element
**prefixlist
,
370 const char *prefixname
,
371 int allow_unknown
, struct cmd_list_element
**list
)
373 struct cmd_list_element
*c
= add_cmd (name
, theclass
, fun
, doc
, list
);
375 c
->prefixlist
= prefixlist
;
376 c
->prefixname
= prefixname
;
377 c
->allow_unknown
= allow_unknown
;
382 /* This is an empty "cfunc". */
384 not_just_help_class_command (char *args
, int from_tty
)
388 /* This is an empty "sfunc". */
389 static void empty_sfunc (char *, int, struct cmd_list_element
*);
392 empty_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
396 /* Add element named NAME to command list LIST (the list for set/show
397 or some sublist thereof).
398 TYPE is set_cmd or show_cmd.
399 CLASS is as in add_cmd.
400 VAR_TYPE is the kind of thing we are setting.
401 VAR is address of the variable being controlled by this command.
402 DOC is the documentation string. */
404 static struct cmd_list_element
*
405 add_set_or_show_cmd (const char *name
,
407 enum command_class theclass
,
411 struct cmd_list_element
**list
)
413 struct cmd_list_element
*c
= add_cmd (name
, theclass
, NULL
, doc
, list
);
415 gdb_assert (type
== set_cmd
|| type
== show_cmd
);
417 c
->var_type
= var_type
;
419 /* This needs to be something besides NULL so that this isn't
420 treated as a help class. */
421 set_cmd_sfunc (c
, empty_sfunc
);
425 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
426 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
427 setting. VAR is address of the variable being controlled by this
428 command. SET_FUNC and SHOW_FUNC are the callback functions (if
429 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
430 strings. PRINT the format string to print the value. SET_RESULT
431 and SHOW_RESULT, if not NULL, are set to the resulting command
435 add_setshow_cmd_full (const char *name
,
436 enum command_class theclass
,
437 var_types var_type
, void *var
,
438 const char *set_doc
, const char *show_doc
,
439 const char *help_doc
,
440 cmd_sfunc_ftype
*set_func
,
441 show_value_ftype
*show_func
,
442 struct cmd_list_element
**set_list
,
443 struct cmd_list_element
**show_list
,
444 struct cmd_list_element
**set_result
,
445 struct cmd_list_element
**show_result
)
447 struct cmd_list_element
*set
;
448 struct cmd_list_element
*show
;
452 if (help_doc
!= NULL
)
454 full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
455 full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
459 full_set_doc
= xstrdup (set_doc
);
460 full_show_doc
= xstrdup (show_doc
);
462 set
= add_set_or_show_cmd (name
, set_cmd
, theclass
, var_type
, var
,
463 full_set_doc
, set_list
);
464 set
->doc_allocated
= 1;
466 if (set_func
!= NULL
)
467 set_cmd_sfunc (set
, set_func
);
469 set_cmd_prefix (set
, set_list
);
471 show
= add_set_or_show_cmd (name
, show_cmd
, theclass
, var_type
, var
,
472 full_show_doc
, show_list
);
473 show
->doc_allocated
= 1;
474 show
->show_value_func
= show_func
;
476 if (set_result
!= NULL
)
478 if (show_result
!= NULL
)
482 /* Add element named NAME to command list LIST (the list for set or
483 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
484 of strings which may follow NAME. VAR is address of the variable
485 which will contain the matching string (from ENUMLIST). */
488 add_setshow_enum_cmd (const char *name
,
489 enum command_class theclass
,
490 const char *const *enumlist
,
493 const char *show_doc
,
494 const char *help_doc
,
495 cmd_sfunc_ftype
*set_func
,
496 show_value_ftype
*show_func
,
497 struct cmd_list_element
**set_list
,
498 struct cmd_list_element
**show_list
)
500 struct cmd_list_element
*c
;
502 add_setshow_cmd_full (name
, theclass
, var_enum
, var
,
503 set_doc
, show_doc
, help_doc
,
510 const char * const auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
512 /* Add an auto-boolean command named NAME to both the set and show
513 command list lists. CLASS is as in add_cmd. VAR is address of the
514 variable which will contain the value. DOC is the documentation
515 string. FUNC is the corresponding callback. */
517 add_setshow_auto_boolean_cmd (const char *name
,
518 enum command_class theclass
,
519 enum auto_boolean
*var
,
520 const char *set_doc
, const char *show_doc
,
521 const char *help_doc
,
522 cmd_sfunc_ftype
*set_func
,
523 show_value_ftype
*show_func
,
524 struct cmd_list_element
**set_list
,
525 struct cmd_list_element
**show_list
)
527 struct cmd_list_element
*c
;
529 add_setshow_cmd_full (name
, theclass
, var_auto_boolean
, var
,
530 set_doc
, show_doc
, help_doc
,
534 c
->enums
= auto_boolean_enums
;
537 /* Add element named NAME to both the set and show command LISTs (the
538 list for set/show or some sublist thereof). CLASS is as in
539 add_cmd. VAR is address of the variable which will contain the
540 value. SET_DOC and SHOW_DOC are the documentation strings. */
542 add_setshow_boolean_cmd (const char *name
, enum command_class theclass
, int *var
,
543 const char *set_doc
, const char *show_doc
,
544 const char *help_doc
,
545 cmd_sfunc_ftype
*set_func
,
546 show_value_ftype
*show_func
,
547 struct cmd_list_element
**set_list
,
548 struct cmd_list_element
**show_list
)
550 static const char *boolean_enums
[] = { "on", "off", NULL
};
551 struct cmd_list_element
*c
;
553 add_setshow_cmd_full (name
, theclass
, var_boolean
, var
,
554 set_doc
, show_doc
, help_doc
,
558 c
->enums
= boolean_enums
;
561 /* Add element named NAME to both the set and show command LISTs (the
562 list for set/show or some sublist thereof). */
564 add_setshow_filename_cmd (const char *name
, enum command_class theclass
,
566 const char *set_doc
, const char *show_doc
,
567 const char *help_doc
,
568 cmd_sfunc_ftype
*set_func
,
569 show_value_ftype
*show_func
,
570 struct cmd_list_element
**set_list
,
571 struct cmd_list_element
**show_list
)
573 struct cmd_list_element
*set_result
;
575 add_setshow_cmd_full (name
, theclass
, var_filename
, var
,
576 set_doc
, show_doc
, help_doc
,
580 set_cmd_completer (set_result
, filename_completer
);
583 /* Add element named NAME to both the set and show command LISTs (the
584 list for set/show or some sublist thereof). */
586 add_setshow_string_cmd (const char *name
, enum command_class theclass
,
588 const char *set_doc
, const char *show_doc
,
589 const char *help_doc
,
590 cmd_sfunc_ftype
*set_func
,
591 show_value_ftype
*show_func
,
592 struct cmd_list_element
**set_list
,
593 struct cmd_list_element
**show_list
)
595 add_setshow_cmd_full (name
, theclass
, var_string
, var
,
596 set_doc
, show_doc
, help_doc
,
602 /* Add element named NAME to both the set and show command LISTs (the
603 list for set/show or some sublist thereof). */
604 struct cmd_list_element
*
605 add_setshow_string_noescape_cmd (const char *name
, enum command_class theclass
,
607 const char *set_doc
, const char *show_doc
,
608 const char *help_doc
,
609 cmd_sfunc_ftype
*set_func
,
610 show_value_ftype
*show_func
,
611 struct cmd_list_element
**set_list
,
612 struct cmd_list_element
**show_list
)
614 struct cmd_list_element
*set_cmd
;
616 add_setshow_cmd_full (name
, theclass
, var_string_noescape
, var
,
617 set_doc
, show_doc
, help_doc
,
624 /* Add element named NAME to both the set and show command LISTs (the
625 list for set/show or some sublist thereof). */
627 add_setshow_optional_filename_cmd (const char *name
, enum command_class theclass
,
629 const char *set_doc
, const char *show_doc
,
630 const char *help_doc
,
631 cmd_sfunc_ftype
*set_func
,
632 show_value_ftype
*show_func
,
633 struct cmd_list_element
**set_list
,
634 struct cmd_list_element
**show_list
)
636 struct cmd_list_element
*set_result
;
638 add_setshow_cmd_full (name
, theclass
, var_optional_filename
, var
,
639 set_doc
, show_doc
, help_doc
,
644 set_cmd_completer (set_result
, filename_completer
);
648 /* Completes on literal "unlimited". Used by integer commands that
649 support a special "unlimited" value. */
651 static VEC (char_ptr
) *
652 integer_unlimited_completer (struct cmd_list_element
*ignore
,
653 const char *text
, const char *word
)
655 static const char * const keywords
[] =
661 return complete_on_enum (keywords
, text
, word
);
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. This
668 function is only used in Python API. Please don't use it elsewhere. */
670 add_setshow_integer_cmd (const char *name
, enum command_class theclass
,
672 const char *set_doc
, const char *show_doc
,
673 const char *help_doc
,
674 cmd_sfunc_ftype
*set_func
,
675 show_value_ftype
*show_func
,
676 struct cmd_list_element
**set_list
,
677 struct cmd_list_element
**show_list
)
679 struct cmd_list_element
*set
;
681 add_setshow_cmd_full (name
, theclass
, var_integer
, var
,
682 set_doc
, show_doc
, help_doc
,
687 set_cmd_completer (set
, integer_unlimited_completer
);
690 /* Add element named NAME to both the set and show command LISTs (the
691 list for set/show or some sublist thereof). CLASS is as in
692 add_cmd. VAR is address of the variable which will contain the
693 value. SET_DOC and SHOW_DOC are the documentation strings. */
695 add_setshow_uinteger_cmd (const char *name
, enum command_class theclass
,
697 const char *set_doc
, const char *show_doc
,
698 const char *help_doc
,
699 cmd_sfunc_ftype
*set_func
,
700 show_value_ftype
*show_func
,
701 struct cmd_list_element
**set_list
,
702 struct cmd_list_element
**show_list
)
704 struct cmd_list_element
*set
;
706 add_setshow_cmd_full (name
, theclass
, var_uinteger
, var
,
707 set_doc
, show_doc
, help_doc
,
712 set_cmd_completer (set
, integer_unlimited_completer
);
715 /* Add element named NAME to both the set and show command LISTs (the
716 list for set/show or some sublist thereof). CLASS is as in
717 add_cmd. VAR is address of the variable which will contain the
718 value. SET_DOC and SHOW_DOC are the documentation strings. */
720 add_setshow_zinteger_cmd (const char *name
, enum command_class theclass
,
722 const char *set_doc
, const char *show_doc
,
723 const char *help_doc
,
724 cmd_sfunc_ftype
*set_func
,
725 show_value_ftype
*show_func
,
726 struct cmd_list_element
**set_list
,
727 struct cmd_list_element
**show_list
)
729 add_setshow_cmd_full (name
, theclass
, var_zinteger
, var
,
730 set_doc
, show_doc
, help_doc
,
737 add_setshow_zuinteger_unlimited_cmd (const char *name
,
738 enum command_class theclass
,
741 const char *show_doc
,
742 const char *help_doc
,
743 cmd_sfunc_ftype
*set_func
,
744 show_value_ftype
*show_func
,
745 struct cmd_list_element
**set_list
,
746 struct cmd_list_element
**show_list
)
748 struct cmd_list_element
*set
;
750 add_setshow_cmd_full (name
, theclass
, var_zuinteger_unlimited
, var
,
751 set_doc
, show_doc
, help_doc
,
756 set_cmd_completer (set
, integer_unlimited_completer
);
759 /* Add element named NAME to both the set and show command LISTs (the
760 list for set/show or some sublist thereof). CLASS is as in
761 add_cmd. VAR is address of the variable which will contain the
762 value. SET_DOC and SHOW_DOC are the documentation strings. */
764 add_setshow_zuinteger_cmd (const char *name
, enum command_class theclass
,
766 const char *set_doc
, const char *show_doc
,
767 const char *help_doc
,
768 cmd_sfunc_ftype
*set_func
,
769 show_value_ftype
*show_func
,
770 struct cmd_list_element
**set_list
,
771 struct cmd_list_element
**show_list
)
773 add_setshow_cmd_full (name
, theclass
, var_zuinteger
, var
,
774 set_doc
, show_doc
, help_doc
,
780 /* Remove the command named NAME from the command list. Return the
781 list commands which were aliased to the deleted command. If the
782 command had no aliases, return NULL. The various *HOOKs are set to
783 the pre- and post-hook commands for the deleted command. If the
784 command does not have a hook, the corresponding out parameter is
787 static struct cmd_list_element
*
788 delete_cmd (const char *name
, struct cmd_list_element
**list
,
789 struct cmd_list_element
**prehook
,
790 struct cmd_list_element
**prehookee
,
791 struct cmd_list_element
**posthook
,
792 struct cmd_list_element
**posthookee
)
794 struct cmd_list_element
*iter
;
795 struct cmd_list_element
**previous_chain_ptr
;
796 struct cmd_list_element
*aliases
= NULL
;
802 previous_chain_ptr
= list
;
804 for (iter
= *previous_chain_ptr
; iter
; iter
= *previous_chain_ptr
)
806 if (strcmp (iter
->name
, name
) == 0)
809 iter
->destroyer (iter
, iter
->context
);
810 if (iter
->hookee_pre
)
811 iter
->hookee_pre
->hook_pre
= 0;
812 *prehook
= iter
->hook_pre
;
813 *prehookee
= iter
->hookee_pre
;
814 if (iter
->hookee_post
)
815 iter
->hookee_post
->hook_post
= 0;
816 if (iter
->doc
&& iter
->doc_allocated
)
817 xfree ((char *) iter
->doc
);
818 *posthook
= iter
->hook_post
;
819 *posthookee
= iter
->hookee_post
;
821 /* Update the link. */
822 *previous_chain_ptr
= iter
->next
;
824 aliases
= iter
->aliases
;
826 /* If this command was an alias, remove it from the list of
828 if (iter
->cmd_pointer
)
830 struct cmd_list_element
**prevp
= &iter
->cmd_pointer
->aliases
;
831 struct cmd_list_element
*a
= *prevp
;
835 prevp
= &a
->alias_chain
;
838 *prevp
= iter
->alias_chain
;
843 /* We won't see another command with the same name. */
847 previous_chain_ptr
= &iter
->next
;
853 /* Shorthands to the commands above. */
855 /* Add an element to the list of info subcommands. */
857 struct cmd_list_element
*
858 add_info (const char *name
, cmd_cfunc_ftype
*fun
, const char *doc
)
860 return add_cmd (name
, class_info
, fun
, doc
, &infolist
);
863 /* Add an alias to the list of info subcommands. */
865 struct cmd_list_element
*
866 add_info_alias (const char *name
, const char *oldname
, int abbrev_flag
)
868 return add_alias_cmd (name
, oldname
, class_run
, abbrev_flag
, &infolist
);
871 /* Add an element to the list of commands. */
873 struct cmd_list_element
*
874 add_com (const char *name
, enum command_class theclass
, cmd_cfunc_ftype
*fun
,
877 return add_cmd (name
, theclass
, fun
, doc
, &cmdlist
);
880 /* Add an alias or abbreviation command to the list of commands. */
882 struct cmd_list_element
*
883 add_com_alias (const char *name
, const char *oldname
, enum command_class theclass
,
886 return add_alias_cmd (name
, oldname
, theclass
, abbrev_flag
, &cmdlist
);
889 /* Add an element with a suppress notification to the list of commands. */
891 struct cmd_list_element
*
892 add_com_suppress_notification (const char *name
, enum command_class theclass
,
893 cmd_cfunc_ftype
*fun
, const char *doc
,
894 int *suppress_notification
)
896 struct cmd_list_element
*element
;
898 element
= add_cmd (name
, theclass
, fun
, doc
, &cmdlist
);
899 element
->suppress_notification
= suppress_notification
;
904 /* Recursively walk the commandlist structures, and print out the
905 documentation of commands that match our regex in either their
906 name, or their documentation.
909 apropos_cmd (struct ui_file
*stream
,
910 struct cmd_list_element
*commandlist
,
911 struct re_pattern_buffer
*regex
, const char *prefix
)
913 struct cmd_list_element
*c
;
916 /* Walk through the commands. */
917 for (c
=commandlist
;c
;c
=c
->next
)
919 returnvalue
= -1; /* Needed to avoid double printing. */
922 /* Try to match against the name. */
923 returnvalue
= re_search (regex
, c
->name
, strlen(c
->name
),
924 0, strlen (c
->name
), NULL
);
925 if (returnvalue
>= 0)
927 print_help_for_command (c
, prefix
,
928 0 /* don't recurse */, stream
);
931 if (c
->doc
!= NULL
&& returnvalue
< 0)
933 /* Try to match against documentation. */
934 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
936 print_help_for_command (c
, prefix
,
937 0 /* don't recurse */, stream
);
940 /* Check if this command has subcommands and is not an
941 abbreviation. We skip listing subcommands of abbreviations
942 in order to avoid duplicates in the output. */
943 if (c
->prefixlist
!= NULL
&& !c
->abbrev_flag
)
945 /* Recursively call ourselves on the subcommand list,
946 passing the right prefix in. */
947 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
952 /* This command really has to deal with two things:
953 1) I want documentation on *this string* (usually called by
956 2) I want documentation on *this list* (usually called by giving a
957 command that requires subcommands. Also called by saying just
960 I am going to split this into two seperate comamnds, help_cmd and
964 help_cmd (const char *command
, struct ui_file
*stream
)
966 struct cmd_list_element
*c
;
970 help_list (cmdlist
, "", all_classes
, stream
);
974 if (strcmp (command
, "all") == 0)
980 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
985 /* There are three cases here.
986 If c->prefixlist is nonzero, we have a prefix command.
987 Print its documentation, then list its subcommands.
989 If c->func is non NULL, we really have a command. Print its
990 documentation and return.
992 If c->func is NULL, we have a class name. Print its
993 documentation (as if it were a command) and then set class to the
994 number of this class so that the commands in the class will be
997 fputs_filtered (c
->doc
, stream
);
998 fputs_filtered ("\n", stream
);
1000 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
1002 fprintf_filtered (stream
, "\n");
1004 /* If this is a prefix command, print it's subcommands. */
1006 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
1008 /* If this is a class name, print all of the commands in the class. */
1009 if (c
->func
== NULL
)
1010 help_list (cmdlist
, "", c
->theclass
, stream
);
1012 if (c
->hook_pre
|| c
->hook_post
)
1013 fprintf_filtered (stream
,
1014 "\nThis command has a hook (or hooks) defined:\n");
1017 fprintf_filtered (stream
,
1018 "\tThis command is run after : %s (pre hook)\n",
1021 fprintf_filtered (stream
,
1022 "\tThis command is run before : %s (post hook)\n",
1023 c
->hook_post
->name
);
1027 * Get a specific kind of help on a command list.
1030 * CMDTYPE is the prefix to use in the title string.
1031 * CLASS is the class with which to list the nodes of this list (see
1032 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
1033 * everything, ALL_CLASSES for just classes, and non-negative for only things
1034 * in a specific class.
1035 * and STREAM is the output stream on which to print things.
1036 * If you call this routine with a class >= 0, it recurses.
1039 help_list (struct cmd_list_element
*list
, const char *cmdtype
,
1040 enum command_class theclass
, struct ui_file
*stream
)
1043 char *cmdtype1
, *cmdtype2
;
1045 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
1047 len
= strlen (cmdtype
);
1048 cmdtype1
= (char *) alloca (len
+ 1);
1050 cmdtype2
= (char *) alloca (len
+ 4);
1055 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
1057 strncpy (cmdtype2
, cmdtype
, len
- 1);
1058 strcpy (cmdtype2
+ len
- 1, " sub");
1061 if (theclass
== all_classes
)
1062 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
1064 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
1066 help_cmd_list (list
, theclass
, cmdtype
, (int) theclass
>= 0, stream
);
1068 if (theclass
== all_classes
)
1070 fprintf_filtered (stream
, "\n\
1071 Type \"help%s\" followed by a class name for a list of commands in ",
1074 fprintf_filtered (stream
, "that class.");
1076 fprintf_filtered (stream
, "\n\
1077 Type \"help all\" for the list of all commands.");
1080 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
1081 cmdtype1
, cmdtype2
);
1083 fputs_filtered ("for ", stream
);
1085 fputs_filtered ("full ", stream
);
1087 fputs_filtered ("documentation.\n", stream
);
1088 fputs_filtered ("Type \"apropos word\" to search "
1089 "for commands related to \"word\".\n", stream
);
1090 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
1095 help_all (struct ui_file
*stream
)
1097 struct cmd_list_element
*c
;
1098 int seen_unclassified
= 0;
1100 for (c
= cmdlist
; c
; c
= c
->next
)
1104 /* If this is a class name, print all of the commands in the
1107 if (c
->func
== NULL
)
1109 fprintf_filtered (stream
, "\nCommand class: %s\n\n", c
->name
);
1110 help_cmd_list (cmdlist
, c
->theclass
, "", 1, stream
);
1114 /* While it's expected that all commands are in some class,
1115 as a safety measure, we'll print commands outside of any
1116 class at the end. */
1118 for (c
= cmdlist
; c
; c
= c
->next
)
1123 if (c
->theclass
== no_class
)
1125 if (!seen_unclassified
)
1127 fprintf_filtered (stream
, "\nUnclassified commands\n\n");
1128 seen_unclassified
= 1;
1130 print_help_for_command (c
, "", 1, stream
);
1136 /* Print only the first line of STR on STREAM. */
1138 print_doc_line (struct ui_file
*stream
, const char *str
)
1140 static char *line_buffer
= 0;
1141 static int line_size
;
1147 line_buffer
= (char *) xmalloc (line_size
);
1150 /* Keep printing '.' or ',' not followed by a whitespace for embedded strings
1153 while (*p
&& *p
!= '\n'
1154 && ((*p
!= '.' && *p
!= ',') || (p
[1] && !isspace (p
[1]))))
1156 if (p
- str
> line_size
- 1)
1158 line_size
= p
- str
+ 1;
1159 xfree (line_buffer
);
1160 line_buffer
= (char *) xmalloc (line_size
);
1162 strncpy (line_buffer
, str
, p
- str
);
1163 line_buffer
[p
- str
] = '\0';
1164 if (islower (line_buffer
[0]))
1165 line_buffer
[0] = toupper (line_buffer
[0]);
1166 fputs_filtered (line_buffer
, stream
);
1169 /* Print one-line help for command C.
1170 If RECURSE is non-zero, also print one-line descriptions
1171 of all prefixed subcommands. */
1173 print_help_for_command (struct cmd_list_element
*c
, const char *prefix
,
1174 int recurse
, struct ui_file
*stream
)
1176 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
1177 print_doc_line (stream
, c
->doc
);
1178 fputs_filtered ("\n", stream
);
1181 && c
->prefixlist
!= 0
1182 && c
->abbrev_flag
== 0)
1183 /* Subcommands of a prefix command typically have 'all_commands'
1184 as class. If we pass CLASS to recursive invocation,
1185 most often we won't see anything. */
1186 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 1, stream
);
1190 * Implement a help command on command list LIST.
1191 * RECURSE should be non-zero if this should be done recursively on
1192 * all sublists of LIST.
1193 * PREFIX is the prefix to print before each command name.
1194 * STREAM is the stream upon which the output should be written.
1195 * THECLASS should be:
1196 * A non-negative class number to list only commands in that
1198 * ALL_COMMANDS to list all commands in list.
1199 * ALL_CLASSES to list all classes in list.
1201 * Note that RECURSE will be active on *all* sublists, not just the
1202 * ones selected by the criteria above (ie. the selection mechanism
1203 * is at the low level, not the high-level).
1206 help_cmd_list (struct cmd_list_element
*list
, enum command_class theclass
,
1207 const char *prefix
, int recurse
, struct ui_file
*stream
)
1209 struct cmd_list_element
*c
;
1211 for (c
= list
; c
; c
= c
->next
)
1213 if (c
->abbrev_flag
== 0
1214 && !c
->cmd_deprecated
1215 && (theclass
== all_commands
1216 || (theclass
== all_classes
&& c
->func
== NULL
)
1217 || (theclass
== c
->theclass
&& c
->func
!= NULL
)))
1219 print_help_for_command (c
, prefix
, recurse
, stream
);
1221 else if (c
->abbrev_flag
== 0
1223 && !c
->cmd_deprecated
1224 && theclass
== class_user
&& c
->prefixlist
!= NULL
)
1225 /* User-defined commands may be subcommands. */
1226 help_cmd_list (*c
->prefixlist
, theclass
, c
->prefixname
,
1232 /* Search the input clist for 'command'. Return the command if
1233 found (or NULL if not), and return the number of commands
1236 static struct cmd_list_element
*
1237 find_cmd (const char *command
, int len
, struct cmd_list_element
*clist
,
1238 int ignore_help_classes
, int *nfound
)
1240 struct cmd_list_element
*found
, *c
;
1244 for (c
= clist
; c
; c
= c
->next
)
1245 if (!strncmp (command
, c
->name
, len
)
1246 && (!ignore_help_classes
|| c
->func
))
1250 if (c
->name
[len
] == '\0')
1259 /* Return the length of command name in TEXT. */
1262 find_command_name_length (const char *text
)
1264 const char *p
= text
;
1266 /* Treating underscores as part of command words is important
1267 so that "set args_foo()" doesn't get interpreted as
1268 "set args _foo()". */
1269 /* Some characters are only used for TUI specific commands.
1270 However, they are always allowed for the sake of consistency.
1272 Note that this is larger than the character set allowed when
1273 creating user-defined commands. */
1275 /* Recognize '!' as a single character command so that, e.g., "!ls"
1276 works as expected. */
1280 while (isalnum (*p
) || *p
== '-' || *p
== '_'
1281 /* Characters used by TUI specific commands. */
1282 || *p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')
1288 /* Return TRUE if NAME is a valid user-defined command name.
1289 This is a stricter subset of all gdb commands,
1290 see find_command_name_length. */
1293 valid_user_defined_cmd_name_p (const char *name
)
1300 /* Alas "42" is a legitimate user-defined command.
1301 In the interests of not breaking anything we preserve that. */
1303 for (p
= name
; *p
!= '\0'; ++p
)
1316 /* This routine takes a line of TEXT and a CLIST in which to start the
1317 lookup. When it returns it will have incremented the text pointer past
1318 the section of text it matched, set *RESULT_LIST to point to the list in
1319 which the last word was matched, and will return a pointer to the cmd
1320 list element which the text matches. It will return NULL if no match at
1321 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1322 matches are possible; in this case *RESULT_LIST will be set to point to
1323 the list in which there are ambiguous choices (and *TEXT will be set to
1324 the ambiguous text string).
1326 If the located command was an abbreviation, this routine returns the base
1327 command of the abbreviation.
1329 It does no error reporting whatsoever; control will always return
1330 to the superior routine.
1332 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1333 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1334 if no prefix command was ever found. For example, in the case of "info a",
1335 "info" matches without ambiguity, but "a" could be "args" or "address", so
1336 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1337 RESULT_LIST should not be interpreted as a pointer to the beginning of a
1338 list; it simply points to a specific command. In the case of an ambiguous
1339 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1340 "info t" can be "info types" or "info target"; upon return *TEXT has been
1341 advanced past "info ").
1343 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1344 affect the operation).
1346 This routine does *not* modify the text pointed to by TEXT.
1348 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1349 are actually help classes rather than commands (i.e. the function field of
1350 the struct cmd_list_element is NULL). */
1352 struct cmd_list_element
*
1353 lookup_cmd_1 (const char **text
, struct cmd_list_element
*clist
,
1354 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1357 int len
, tmp
, nfound
;
1358 struct cmd_list_element
*found
, *c
;
1359 const char *line
= *text
;
1361 while (**text
== ' ' || **text
== '\t')
1364 /* Identify the name of the command. */
1365 len
= find_command_name_length (*text
);
1367 /* If nothing but whitespace, return 0. */
1371 /* *text and p now bracket the first command word to lookup (and
1372 it's length is len). We copy this into a local temporary. */
1375 command
= (char *) alloca (len
+ 1);
1376 memcpy (command
, *text
, len
);
1377 command
[len
] = '\0';
1382 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1384 /* If nothing matches, we have a simple failure. */
1390 if (result_list
!= NULL
)
1391 /* Will be modified in calling routine
1392 if we know what the prefix command is. */
1394 return CMD_LIST_AMBIGUOUS
; /* Ambiguous. */
1397 /* We've matched something on this list. Move text pointer forward. */
1401 if (found
->cmd_pointer
)
1403 /* We drop the alias (abbreviation) in favor of the command it
1404 is pointing to. If the alias is deprecated, though, we need to
1405 warn the user about it before we drop it. Note that while we
1406 are warning about the alias, we may also warn about the command
1407 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1410 if (found
->deprecated_warn_user
)
1411 deprecated_cmd_warning (line
);
1412 found
= found
->cmd_pointer
;
1414 /* If we found a prefix command, keep looking. */
1416 if (found
->prefixlist
)
1418 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1419 ignore_help_classes
);
1422 /* Didn't find anything; this is as far as we got. */
1423 if (result_list
!= NULL
)
1424 *result_list
= clist
;
1427 else if (c
== CMD_LIST_AMBIGUOUS
)
1429 /* We've gotten this far properly, but the next step is
1430 ambiguous. We need to set the result list to the best
1431 we've found (if an inferior hasn't already set it). */
1432 if (result_list
!= NULL
)
1434 /* This used to say *result_list = *found->prefixlist.
1435 If that was correct, need to modify the documentation
1436 at the top of this function to clarify what is
1437 supposed to be going on. */
1438 *result_list
= found
;
1449 if (result_list
!= NULL
)
1450 *result_list
= clist
;
1455 /* All this hair to move the space to the front of cmdtype */
1458 undef_cmd_error (const char *cmdtype
, const char *q
)
1460 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1463 *cmdtype
? " " : "",
1464 (int) strlen (cmdtype
) - 1,
1468 /* Look up the contents of *LINE as a command in the command list LIST.
1469 LIST is a chain of struct cmd_list_element's.
1470 If it is found, return the struct cmd_list_element for that command
1471 and update *LINE to point after the command name, at the first argument.
1472 If not found, call error if ALLOW_UNKNOWN is zero
1473 otherwise (or if error returns) return zero.
1474 Call error if specified command is ambiguous,
1475 unless ALLOW_UNKNOWN is negative.
1476 CMDTYPE precedes the word "command" in the error message.
1478 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1479 elements which are actually help classes rather than commands (i.e.
1480 the function field of the struct cmd_list_element is 0). */
1482 struct cmd_list_element
*
1483 lookup_cmd (const char **line
, struct cmd_list_element
*list
,
1484 const char *cmdtype
,
1485 int allow_unknown
, int ignore_help_classes
)
1487 struct cmd_list_element
*last_list
= 0;
1488 struct cmd_list_element
*c
;
1490 /* Note: Do not remove trailing whitespace here because this
1491 would be wrong for complete_command. Jim Kingdon */
1494 error (_("Lack of needed %scommand"), cmdtype
);
1496 c
= lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1503 int len
= find_command_name_length (*line
);
1505 q
= (char *) alloca (len
+ 1);
1506 strncpy (q
, *line
, len
);
1508 undef_cmd_error (cmdtype
, q
);
1513 else if (c
== CMD_LIST_AMBIGUOUS
)
1515 /* Ambigous. Local values should be off prefixlist or called
1517 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1519 const char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1520 struct cmd_list_element
*local_list
=
1521 (last_list
? *(last_list
->prefixlist
) : list
);
1523 if (local_allow_unknown
< 0)
1526 return last_list
; /* Found something. */
1528 return 0; /* Found nothing. */
1532 /* Report as error. */
1537 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1538 && (*line
)[amb_len
] != '\t');
1543 for (c
= local_list
; c
; c
= c
->next
)
1544 if (!strncmp (*line
, c
->name
, amb_len
))
1546 if (strlen (ambbuf
) + strlen (c
->name
) + 6
1547 < (int) sizeof ambbuf
)
1549 if (strlen (ambbuf
))
1550 strcat (ambbuf
, ", ");
1551 strcat (ambbuf
, c
->name
);
1555 strcat (ambbuf
, "..");
1559 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1561 return 0; /* lint */
1566 if (c
->type
== set_cmd
&& **line
!= '\0' && !isspace (**line
))
1567 error (_("Argument must be preceded by space."));
1569 /* We've got something. It may still not be what the caller
1570 wants (if this command *needs* a subcommand). */
1571 while (**line
== ' ' || **line
== '\t')
1574 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1575 undef_cmd_error (c
->prefixname
, *line
);
1577 /* Seems to be what he wants. Return it. */
1583 /* We are here presumably because an alias or command in TEXT is
1584 deprecated and a warning message should be generated. This
1585 function decodes TEXT and potentially generates a warning message
1588 Example for 'set endian big' which has a fictitious alias 'seb'.
1590 If alias wasn't used in TEXT, and the command is deprecated:
1591 "warning: 'set endian big' is deprecated."
1593 If alias was used, and only the alias is deprecated:
1594 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1596 If alias was used and command is deprecated (regardless of whether
1597 the alias itself is deprecated:
1599 "warning: 'set endian big' (seb) is deprecated."
1601 After the message has been sent, clear the appropriate flags in the
1602 command and/or the alias so the user is no longer bothered.
1606 deprecated_cmd_warning (const char *text
)
1608 struct cmd_list_element
*alias
= NULL
;
1609 struct cmd_list_element
*prefix_cmd
= NULL
;
1610 struct cmd_list_element
*cmd
= NULL
;
1612 if (!lookup_cmd_composition (text
, &alias
, &prefix_cmd
, &cmd
))
1613 /* Return if text doesn't evaluate to a command. */
1616 if (!((alias
? alias
->deprecated_warn_user
: 0)
1617 || cmd
->deprecated_warn_user
) )
1618 /* Return if nothing is deprecated. */
1621 printf_filtered ("Warning:");
1623 if (alias
&& !cmd
->cmd_deprecated
)
1624 printf_filtered (" '%s', an alias for the", alias
->name
);
1626 printf_filtered (" command '");
1629 printf_filtered ("%s", prefix_cmd
->prefixname
);
1631 printf_filtered ("%s", cmd
->name
);
1633 if (alias
&& cmd
->cmd_deprecated
)
1634 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1636 printf_filtered ("' is deprecated.\n");
1639 /* If it is only the alias that is deprecated, we want to indicate
1640 the new alias, otherwise we'll indicate the new command. */
1642 if (alias
&& !cmd
->cmd_deprecated
)
1644 if (alias
->replacement
)
1645 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1647 printf_filtered ("No alternative known.\n\n");
1651 if (cmd
->replacement
)
1652 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1654 printf_filtered ("No alternative known.\n\n");
1657 /* We've warned you, now we'll keep quiet. */
1659 alias
->deprecated_warn_user
= 0;
1661 cmd
->deprecated_warn_user
= 0;
1665 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1666 Return 1 on success, 0 on failure.
1668 If LINE refers to an alias, *alias will point to that alias.
1670 If LINE is a postfix command (i.e. one that is preceded by a prefix
1671 command) set *prefix_cmd.
1673 Set *cmd to point to the command LINE indicates.
1675 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1676 exist, they are NULL when we return.
1680 lookup_cmd_composition (const char *text
,
1681 struct cmd_list_element
**alias
,
1682 struct cmd_list_element
**prefix_cmd
,
1683 struct cmd_list_element
**cmd
)
1686 int len
, tmp
, nfound
;
1687 struct cmd_list_element
*cur_list
;
1688 struct cmd_list_element
*prev_cmd
;
1698 /* Go through as many command lists as we need to,
1699 to find the command TEXT refers to. */
1703 while (*text
== ' ' || *text
== '\t')
1706 /* Identify the name of the command. */
1707 len
= find_command_name_length (text
);
1709 /* If nothing but whitespace, return. */
1713 /* Text is the start of the first command word to lookup (and
1714 it's length is len). We copy this into a local temporary. */
1716 command
= (char *) alloca (len
+ 1);
1717 memcpy (command
, text
, len
);
1718 command
[len
] = '\0';
1723 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1725 if (*cmd
== CMD_LIST_AMBIGUOUS
)
1727 return 0; /* ambiguous */
1731 return 0; /* nothing found */
1734 if ((*cmd
)->cmd_pointer
)
1736 /* cmd was actually an alias, we note that an alias was
1737 used (by assigning *alais) and we set *cmd. */
1739 *cmd
= (*cmd
)->cmd_pointer
;
1741 *prefix_cmd
= prev_cmd
;
1743 if ((*cmd
)->prefixlist
)
1744 cur_list
= *(*cmd
)->prefixlist
;
1752 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1754 /* Return a vector of char pointers which point to the different
1755 possible completions in LIST of TEXT.
1757 WORD points in the same buffer as TEXT, and completions should be
1758 returned relative to this position. For example, suppose TEXT is
1759 "foo" and we want to complete to "foobar". If WORD is "oo", return
1760 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1763 complete_on_cmdlist (struct cmd_list_element
*list
,
1764 const char *text
, const char *word
,
1765 int ignore_help_classes
)
1767 struct cmd_list_element
*ptr
;
1768 VEC (char_ptr
) *matchlist
= NULL
;
1769 int textlen
= strlen (text
);
1771 int saw_deprecated_match
= 0;
1773 /* We do one or two passes. In the first pass, we skip deprecated
1774 commands. If we see no matching commands in the first pass, and
1775 if we did happen to see a matching deprecated command, we do
1776 another loop to collect those. */
1777 for (pass
= 0; matchlist
== 0 && pass
< 2; ++pass
)
1779 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1780 if (!strncmp (ptr
->name
, text
, textlen
)
1781 && !ptr
->abbrev_flag
1782 && (!ignore_help_classes
|| ptr
->func
1783 || ptr
->prefixlist
))
1789 if (ptr
->cmd_deprecated
)
1791 saw_deprecated_match
= 1;
1796 match
= (char *) xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1798 strcpy (match
, ptr
->name
);
1799 else if (word
> text
)
1801 /* Return some portion of ptr->name. */
1802 strcpy (match
, ptr
->name
+ (word
- text
));
1806 /* Return some of text plus ptr->name. */
1807 strncpy (match
, word
, text
- word
);
1808 match
[text
- word
] = '\0';
1809 strcat (match
, ptr
->name
);
1811 VEC_safe_push (char_ptr
, matchlist
, match
);
1813 /* If we saw no matching deprecated commands in the first pass,
1815 if (!saw_deprecated_match
)
1822 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1824 /* Return a vector of char pointers which point to the different
1825 possible completions in CMD of TEXT.
1827 WORD points in the same buffer as TEXT, and completions should be
1828 returned relative to this position. For example, suppose TEXT is "foo"
1829 and we want to complete to "foobar". If WORD is "oo", return
1830 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1833 complete_on_enum (const char *const *enumlist
,
1834 const char *text
, const char *word
)
1836 VEC (char_ptr
) *matchlist
= NULL
;
1837 int textlen
= strlen (text
);
1841 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1842 if (strncmp (name
, text
, textlen
) == 0)
1846 match
= (char *) xmalloc (strlen (word
) + strlen (name
) + 1);
1848 strcpy (match
, name
);
1849 else if (word
> text
)
1851 /* Return some portion of name. */
1852 strcpy (match
, name
+ (word
- text
));
1856 /* Return some of text plus name. */
1857 strncpy (match
, word
, text
- word
);
1858 match
[text
- word
] = '\0';
1859 strcat (match
, name
);
1861 VEC_safe_push (char_ptr
, matchlist
, match
);
1868 /* Check function pointer. */
1870 cmd_func_p (struct cmd_list_element
*cmd
)
1872 return (cmd
->func
!= NULL
);
1876 /* Call the command function. */
1878 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1880 if (cmd_func_p (cmd
))
1882 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1884 if (cmd
->suppress_notification
!= NULL
)
1885 restore_suppress
.emplace (cmd
->suppress_notification
, 1);
1887 (*cmd
->func
) (cmd
, args
, from_tty
);
1890 error (_("Invalid command"));
1894 cli_user_command_p (struct cmd_list_element
*cmd
)
1896 return (cmd
->theclass
== class_user
1897 && (cmd
->func
== do_cfunc
|| cmd
->func
== do_sfunc
));