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_handle_brkchars_ftype *func)
171 cmd->completer_handle_brkchars = func;
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, symbol_completer);
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. */
661 integer_unlimited_completer (struct cmd_list_element *ignore,
662 completion_tracker &tracker,
663 const char *text, const char *word)
665 static const char * const keywords[] =
671 complete_on_enum (tracker, keywords, text, word);
674 /* Add element named NAME to both the set and show command LISTs (the
675 list for set/show or some sublist thereof). CLASS is as in
676 add_cmd. VAR is address of the variable which will contain the
677 value. SET_DOC and SHOW_DOC are the documentation strings. This
678 function is only used in Python API. Please don't use it elsewhere. */
680 add_setshow_integer_cmd (const char *name, enum command_class theclass,
682 const char *set_doc, const char *show_doc,
683 const char *help_doc,
684 cmd_sfunc_ftype *set_func,
685 show_value_ftype *show_func,
686 struct cmd_list_element **set_list,
687 struct cmd_list_element **show_list)
689 struct cmd_list_element *set;
691 add_setshow_cmd_full (name, theclass, var_integer, var,
692 set_doc, show_doc, help_doc,
697 set_cmd_completer (set, integer_unlimited_completer);
700 /* Add element named NAME to both the set and show command LISTs (the
701 list for set/show or some sublist thereof). CLASS is as in
702 add_cmd. VAR is address of the variable which will contain the
703 value. SET_DOC and SHOW_DOC are the documentation strings. */
705 add_setshow_uinteger_cmd (const char *name, enum command_class theclass,
707 const char *set_doc, const char *show_doc,
708 const char *help_doc,
709 cmd_sfunc_ftype *set_func,
710 show_value_ftype *show_func,
711 struct cmd_list_element **set_list,
712 struct cmd_list_element **show_list)
714 struct cmd_list_element *set;
716 add_setshow_cmd_full (name, theclass, var_uinteger, var,
717 set_doc, show_doc, help_doc,
722 set_cmd_completer (set, integer_unlimited_completer);
725 /* Add element named NAME to both the set and show command LISTs (the
726 list for set/show or some sublist thereof). CLASS is as in
727 add_cmd. VAR is address of the variable which will contain the
728 value. SET_DOC and SHOW_DOC are the documentation strings. */
730 add_setshow_zinteger_cmd (const char *name, enum command_class theclass,
732 const char *set_doc, const char *show_doc,
733 const char *help_doc,
734 cmd_sfunc_ftype *set_func,
735 show_value_ftype *show_func,
736 struct cmd_list_element **set_list,
737 struct cmd_list_element **show_list)
739 add_setshow_cmd_full (name, theclass, var_zinteger, var,
740 set_doc, show_doc, help_doc,
747 add_setshow_zuinteger_unlimited_cmd (const char *name,
748 enum command_class theclass,
751 const char *show_doc,
752 const char *help_doc,
753 cmd_sfunc_ftype *set_func,
754 show_value_ftype *show_func,
755 struct cmd_list_element **set_list,
756 struct cmd_list_element **show_list)
758 struct cmd_list_element *set;
760 add_setshow_cmd_full (name, theclass, var_zuinteger_unlimited, var,
761 set_doc, show_doc, help_doc,
766 set_cmd_completer (set, integer_unlimited_completer);
769 /* Add element named NAME to both the set and show command LISTs (the
770 list for set/show or some sublist thereof). CLASS is as in
771 add_cmd. VAR is address of the variable which will contain the
772 value. SET_DOC and SHOW_DOC are the documentation strings. */
774 add_setshow_zuinteger_cmd (const char *name, enum command_class theclass,
776 const char *set_doc, const char *show_doc,
777 const char *help_doc,
778 cmd_sfunc_ftype *set_func,
779 show_value_ftype *show_func,
780 struct cmd_list_element **set_list,
781 struct cmd_list_element **show_list)
783 add_setshow_cmd_full (name, theclass, var_zuinteger, var,
784 set_doc, show_doc, help_doc,
790 /* Remove the command named NAME from the command list. Return the
791 list commands which were aliased to the deleted command. If the
792 command had no aliases, return NULL. The various *HOOKs are set to
793 the pre- and post-hook commands for the deleted command. If the
794 command does not have a hook, the corresponding out parameter is
797 static struct cmd_list_element *
798 delete_cmd (const char *name, struct cmd_list_element **list,
799 struct cmd_list_element **prehook,
800 struct cmd_list_element **prehookee,
801 struct cmd_list_element **posthook,
802 struct cmd_list_element **posthookee)
804 struct cmd_list_element *iter;
805 struct cmd_list_element **previous_chain_ptr;
806 struct cmd_list_element *aliases = NULL;
812 previous_chain_ptr = list;
814 for (iter = *previous_chain_ptr; iter; iter = *previous_chain_ptr)
816 if (strcmp (iter->name, name) == 0)
819 iter->destroyer (iter, iter->context);
820 if (iter->hookee_pre)
821 iter->hookee_pre->hook_pre = 0;
822 *prehook = iter->hook_pre;
823 *prehookee = iter->hookee_pre;
824 if (iter->hookee_post)
825 iter->hookee_post->hook_post = 0;
826 if (iter->doc && iter->doc_allocated)
827 xfree ((char *) iter->doc);
828 *posthook = iter->hook_post;
829 *posthookee = iter->hookee_post;
831 /* Update the link. */
832 *previous_chain_ptr = iter->next;
834 aliases = iter->aliases;
836 /* If this command was an alias, remove it from the list of
838 if (iter->cmd_pointer)
840 struct cmd_list_element **prevp = &iter->cmd_pointer->aliases;
841 struct cmd_list_element *a = *prevp;
845 prevp = &a->alias_chain;
848 *prevp = iter->alias_chain;
853 /* We won't see another command with the same name. */
857 previous_chain_ptr = &iter->next;
863 /* Shorthands to the commands above. */
865 /* Add an element to the list of info subcommands. */
867 struct cmd_list_element *
868 add_info (const char *name, cmd_cfunc_ftype *fun, const char *doc)
870 return add_cmd (name, class_info, fun, doc, &infolist);
873 /* Add an alias to the list of info subcommands. */
875 struct cmd_list_element *
876 add_info_alias (const char *name, const char *oldname, int abbrev_flag)
878 return add_alias_cmd (name, oldname, class_run, abbrev_flag, &infolist);
881 /* Add an element to the list of commands. */
883 struct cmd_list_element *
884 add_com (const char *name, enum command_class theclass, cmd_cfunc_ftype *fun,
887 return add_cmd (name, theclass, fun, doc, &cmdlist);
890 /* Add an alias or abbreviation command to the list of commands. */
892 struct cmd_list_element *
893 add_com_alias (const char *name, const char *oldname, enum command_class theclass,
896 return add_alias_cmd (name, oldname, theclass, abbrev_flag, &cmdlist);
899 /* Add an element with a suppress notification to the list of commands. */
901 struct cmd_list_element *
902 add_com_suppress_notification (const char *name, enum command_class theclass,
903 cmd_cfunc_ftype *fun, const char *doc,
904 int *suppress_notification)
906 struct cmd_list_element *element;
908 element = add_cmd (name, theclass, fun, doc, &cmdlist);
909 element->suppress_notification = suppress_notification;
914 /* Recursively walk the commandlist structures, and print out the
915 documentation of commands that match our regex in either their
916 name, or their documentation.
919 apropos_cmd (struct ui_file *stream,
920 struct cmd_list_element *commandlist,
921 compiled_regex ®ex, const char *prefix)
923 struct cmd_list_element *c;
926 /* Walk through the commands. */
927 for (c=commandlist;c;c=c->next)
929 returnvalue = -1; /* Needed to avoid double printing. */
932 size_t name_len = strlen (c->name);
934 /* Try to match against the name. */
935 returnvalue = regex.search (c->name, name_len, 0, name_len, NULL);
936 if (returnvalue >= 0)
938 print_help_for_command (c, prefix,
939 0 /* don't recurse */, stream);
942 if (c->doc != NULL && returnvalue < 0)
944 size_t doc_len = strlen (c->doc);
946 /* Try to match against documentation. */
947 if (regex.search (c->doc, doc_len, 0, doc_len, NULL) >= 0)
949 print_help_for_command (c, prefix,
950 0 /* don't recurse */, stream);
953 /* Check if this command has subcommands and is not an
954 abbreviation. We skip listing subcommands of abbreviations
955 in order to avoid duplicates in the output. */
956 if (c->prefixlist != NULL && !c->abbrev_flag)
958 /* Recursively call ourselves on the subcommand list,
959 passing the right prefix in. */
960 apropos_cmd (stream,*c->prefixlist,regex,c->prefixname);
965 /* This command really has to deal with two things:
966 1) I want documentation on *this string* (usually called by
969 2) I want documentation on *this list* (usually called by giving a
970 command that requires subcommands. Also called by saying just
973 I am going to split this into two seperate comamnds, help_cmd and
977 help_cmd (const char *command, struct ui_file *stream)
979 struct cmd_list_element *c;
983 help_list (cmdlist, "", all_classes, stream);
987 if (strcmp (command, "all") == 0)
993 c = lookup_cmd (&command, cmdlist, "", 0, 0);
998 /* There are three cases here.
999 If c->prefixlist is nonzero, we have a prefix command.
1000 Print its documentation, then list its subcommands.
1002 If c->func is non NULL, we really have a command. Print its
1003 documentation and return.
1005 If c->func is NULL, we have a class name. Print its
1006 documentation (as if it were a command) and then set class to the
1007 number of this class so that the commands in the class will be
1010 fputs_filtered (c->doc, stream);
1011 fputs_filtered ("\n", stream);
1013 if (c->prefixlist == 0 && c->func != NULL)
1015 fprintf_filtered (stream, "\n");
1017 /* If this is a prefix command, print it's subcommands. */
1019 help_list (*c->prefixlist, c->prefixname, all_commands, stream);
1021 /* If this is a class name, print all of the commands in the class. */
1022 if (c->func == NULL)
1023 help_list (cmdlist, "", c->theclass, stream);
1025 if (c->hook_pre || c->hook_post)
1026 fprintf_filtered (stream,
1027 "\nThis command has a hook (or hooks) defined:\n");
1030 fprintf_filtered (stream,
1031 "\tThis command is run after : %s (pre hook)\n",
1034 fprintf_filtered (stream,
1035 "\tThis command is run before : %s (post hook)\n",
1036 c->hook_post->name);
1040 * Get a specific kind of help on a command list.
1043 * CMDTYPE is the prefix to use in the title string.
1044 * CLASS is the class with which to list the nodes of this list (see
1045 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
1046 * everything, ALL_CLASSES for just classes, and non-negative for only things
1047 * in a specific class.
1048 * and STREAM is the output stream on which to print things.
1049 * If you call this routine with a class >= 0, it recurses.
1052 help_list (struct cmd_list_element *list, const char *cmdtype,
1053 enum command_class theclass, struct ui_file *stream)
1056 char *cmdtype1, *cmdtype2;
1058 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
1060 len = strlen (cmdtype);
1061 cmdtype1 = (char *) alloca (len + 1);
1063 cmdtype2 = (char *) alloca (len + 4);
1068 strncpy (cmdtype1 + 1, cmdtype, len - 1);
1070 strncpy (cmdtype2, cmdtype, len - 1);
1071 strcpy (cmdtype2 + len - 1, " sub");
1074 if (theclass == all_classes)
1075 fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2);
1077 fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);
1079 help_cmd_list (list, theclass, cmdtype, (int) theclass >= 0, stream);
1081 if (theclass == all_classes)
1083 fprintf_filtered (stream, "\n\
1084 Type \"help%s\" followed by a class name for a list of commands in ",
1087 fprintf_filtered (stream, "that class.");
1089 fprintf_filtered (stream, "\n\
1090 Type \"help all\" for the list of all commands.");
1093 fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ",
1094 cmdtype1, cmdtype2);
1096 fputs_filtered ("for ", stream);
1098 fputs_filtered ("full ", stream);
1100 fputs_filtered ("documentation.\n", stream);
1101 fputs_filtered ("Type \"apropos word\" to search "
1102 "for commands related to \"word\".\n", stream);
1103 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
1108 help_all (struct ui_file *stream)
1110 struct cmd_list_element *c;
1111 int seen_unclassified = 0;
1113 for (c = cmdlist; c; c = c->next)
1117 /* If this is a class name, print all of the commands in the
1120 if (c->func == NULL)
1122 fprintf_filtered (stream, "\nCommand class: %s\n\n", c->name);
1123 help_cmd_list (cmdlist, c->theclass, "", 1, stream);
1127 /* While it's expected that all commands are in some class,
1128 as a safety measure, we'll print commands outside of any
1129 class at the end. */
1131 for (c = cmdlist; c; c = c->next)
1136 if (c->theclass == no_class)
1138 if (!seen_unclassified)
1140 fprintf_filtered (stream, "\nUnclassified commands\n\n");
1141 seen_unclassified = 1;
1143 print_help_for_command (c, "", 1, stream);
1149 /* Print only the first line of STR on STREAM. */
1151 print_doc_line (struct ui_file *stream, const char *str)
1153 static char *line_buffer = 0;
1154 static int line_size;
1160 line_buffer = (char *) xmalloc (line_size);
1163 /* Keep printing '.' or ',' not followed by a whitespace for embedded strings
1166 while (*p && *p != '\n'
1167 && ((*p != '.' && *p != ',') || (p[1] && !isspace (p[1]))))
1169 if (p - str > line_size - 1)
1171 line_size = p - str + 1;
1172 xfree (line_buffer);
1173 line_buffer = (char *) xmalloc (line_size);
1175 strncpy (line_buffer, str, p - str);
1176 line_buffer[p - str] = '\0';
1177 if (islower (line_buffer[0]))
1178 line_buffer[0] = toupper (line_buffer[0]);
1179 fputs_filtered (line_buffer, stream);
1182 /* Print one-line help for command C.
1183 If RECURSE is non-zero, also print one-line descriptions
1184 of all prefixed subcommands. */
1186 print_help_for_command (struct cmd_list_element *c, const char *prefix,
1187 int recurse, struct ui_file *stream)
1189 fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
1190 print_doc_line (stream, c->doc);
1191 fputs_filtered ("\n", stream);
1194 && c->prefixlist != 0
1195 && c->abbrev_flag == 0)
1196 /* Subcommands of a prefix command typically have 'all_commands'
1197 as class. If we pass CLASS to recursive invocation,
1198 most often we won't see anything. */
1199 help_cmd_list (*c->prefixlist, all_commands, c->prefixname, 1, stream);
1203 * Implement a help command on command list LIST.
1204 * RECURSE should be non-zero if this should be done recursively on
1205 * all sublists of LIST.
1206 * PREFIX is the prefix to print before each command name.
1207 * STREAM is the stream upon which the output should be written.
1208 * THECLASS should be:
1209 * A non-negative class number to list only commands in that
1211 * ALL_COMMANDS to list all commands in list.
1212 * ALL_CLASSES to list all classes in list.
1214 * Note that RECURSE will be active on *all* sublists, not just the
1215 * ones selected by the criteria above (ie. the selection mechanism
1216 * is at the low level, not the high-level).
1219 help_cmd_list (struct cmd_list_element *list, enum command_class theclass,
1220 const char *prefix, int recurse, struct ui_file *stream)
1222 struct cmd_list_element *c;
1224 for (c = list; c; c = c->next)
1226 if (c->abbrev_flag == 0
1227 && !c->cmd_deprecated
1228 && (theclass == all_commands
1229 || (theclass == all_classes && c->func == NULL)
1230 || (theclass == c->theclass && c->func != NULL)))
1232 print_help_for_command (c, prefix, recurse, stream);
1234 else if (c->abbrev_flag == 0
1236 && !c->cmd_deprecated
1237 && theclass == class_user && c->prefixlist != NULL)
1238 /* User-defined commands may be subcommands. */
1239 help_cmd_list (*c->prefixlist, theclass, c->prefixname,
1245 /* Search the input clist for 'command'. Return the command if
1246 found (or NULL if not), and return the number of commands
1249 static struct cmd_list_element *
1250 find_cmd (const char *command, int len, struct cmd_list_element *clist,
1251 int ignore_help_classes, int *nfound)
1253 struct cmd_list_element *found, *c;
1257 for (c = clist; c; c = c->next)
1258 if (!strncmp (command, c->name, len)
1259 && (!ignore_help_classes || c->func))
1263 if (c->name[len] == '\0')
1272 /* Return the length of command name in TEXT. */
1275 find_command_name_length (const char *text)
1277 const char *p = text;
1279 /* Treating underscores as part of command words is important
1280 so that "set args_foo()" doesn't get interpreted as
1281 "set args _foo()". */
1282 /* Some characters are only used for TUI specific commands.
1283 However, they are always allowed for the sake of consistency.
1285 Note that this is larger than the character set allowed when
1286 creating user-defined commands. */
1288 /* Recognize '!' as a single character command so that, e.g., "!ls"
1289 works as expected. */
1293 while (isalnum (*p) || *p == '-' || *p == '_'
1294 /* Characters used by TUI specific commands. */
1295 || *p == '+' || *p == '<' || *p == '>' || *p == '$')
1301 /* Return TRUE if NAME is a valid user-defined command name.
1302 This is a stricter subset of all gdb commands,
1303 see find_command_name_length. */
1306 valid_user_defined_cmd_name_p (const char *name)
1313 /* Alas "42" is a legitimate user-defined command.
1314 In the interests of not breaking anything we preserve that. */
1316 for (p = name; *p != '\0'; ++p)
1329 /* This routine takes a line of TEXT and a CLIST in which to start the
1330 lookup. When it returns it will have incremented the text pointer past
1331 the section of text it matched, set *RESULT_LIST to point to the list in
1332 which the last word was matched, and will return a pointer to the cmd
1333 list element which the text matches. It will return NULL if no match at
1334 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1335 matches are possible; in this case *RESULT_LIST will be set to point to
1336 the list in which there are ambiguous choices (and *TEXT will be set to
1337 the ambiguous text string).
1339 If the located command was an abbreviation, this routine returns the base
1340 command of the abbreviation.
1342 It does no error reporting whatsoever; control will always return
1343 to the superior routine.
1345 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1346 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1347 if no prefix command was ever found. For example, in the case of "info a",
1348 "info" matches without ambiguity, but "a" could be "args" or "address", so
1349 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1350 RESULT_LIST should not be interpreted as a pointer to the beginning of a
1351 list; it simply points to a specific command. In the case of an ambiguous
1352 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1353 "info t" can be "info types" or "info target"; upon return *TEXT has been
1354 advanced past "info ").
1356 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1357 affect the operation).
1359 This routine does *not* modify the text pointed to by TEXT.
1361 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1362 are actually help classes rather than commands (i.e. the function field of
1363 the struct cmd_list_element is NULL). */
1365 struct cmd_list_element *
1366 lookup_cmd_1 (const char **text, struct cmd_list_element *clist,
1367 struct cmd_list_element **result_list, int ignore_help_classes)
1370 int len, tmp, nfound;
1371 struct cmd_list_element *found, *c;
1372 const char *line = *text;
1374 while (**text == ' ' || **text == '\t')
1377 /* Identify the name of the command. */
1378 len = find_command_name_length (*text);
1380 /* If nothing but whitespace, return 0. */
1384 /* *text and p now bracket the first command word to lookup (and
1385 it's length is len). We copy this into a local temporary. */
1388 command = (char *) alloca (len + 1);
1389 memcpy (command, *text, len);
1390 command[len] = '\0';
1395 found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1397 /* If nothing matches, we have a simple failure. */
1403 if (result_list != NULL)
1404 /* Will be modified in calling routine
1405 if we know what the prefix command is. */
1407 return CMD_LIST_AMBIGUOUS; /* Ambiguous. */
1410 /* We've matched something on this list. Move text pointer forward. */
1414 if (found->cmd_pointer)
1416 /* We drop the alias (abbreviation) in favor of the command it
1417 is pointing to. If the alias is deprecated, though, we need to
1418 warn the user about it before we drop it. Note that while we
1419 are warning about the alias, we may also warn about the command
1420 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1423 if (found->deprecated_warn_user)
1424 deprecated_cmd_warning (line);
1425 found = found->cmd_pointer;
1427 /* If we found a prefix command, keep looking. */
1429 if (found->prefixlist)
1431 c = lookup_cmd_1 (text, *found->prefixlist, result_list,
1432 ignore_help_classes);
1435 /* Didn't find anything; this is as far as we got. */
1436 if (result_list != NULL)
1437 *result_list = clist;
1440 else if (c == CMD_LIST_AMBIGUOUS)
1442 /* We've gotten this far properly, but the next step is
1443 ambiguous. We need to set the result list to the best
1444 we've found (if an inferior hasn't already set it). */
1445 if (result_list != NULL)
1447 /* This used to say *result_list = *found->prefixlist.
1448 If that was correct, need to modify the documentation
1449 at the top of this function to clarify what is
1450 supposed to be going on. */
1451 *result_list = found;
1462 if (result_list != NULL)
1463 *result_list = clist;
1468 /* All this hair to move the space to the front of cmdtype */
1471 undef_cmd_error (const char *cmdtype, const char *q)
1473 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1476 *cmdtype ? " " : "",
1477 (int) strlen (cmdtype) - 1,
1481 /* Look up the contents of *LINE as a command in the command list LIST.
1482 LIST is a chain of struct cmd_list_element's.
1483 If it is found, return the struct cmd_list_element for that command
1484 and update *LINE to point after the command name, at the first argument.
1485 If not found, call error if ALLOW_UNKNOWN is zero
1486 otherwise (or if error returns) return zero.
1487 Call error if specified command is ambiguous,
1488 unless ALLOW_UNKNOWN is negative.
1489 CMDTYPE precedes the word "command" in the error message.
1491 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1492 elements which are actually help classes rather than commands (i.e.
1493 the function field of the struct cmd_list_element is 0). */
1495 struct cmd_list_element *
1496 lookup_cmd (const char **line, struct cmd_list_element *list,
1497 const char *cmdtype,
1498 int allow_unknown, int ignore_help_classes)
1500 struct cmd_list_element *last_list = 0;
1501 struct cmd_list_element *c;
1503 /* Note: Do not remove trailing whitespace here because this
1504 would be wrong for complete_command. Jim Kingdon */
1507 error (_("Lack of needed %scommand"), cmdtype);
1509 c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
1516 int len = find_command_name_length (*line);
1518 q = (char *) alloca (len + 1);
1519 strncpy (q, *line, len);
1521 undef_cmd_error (cmdtype, q);
1526 else if (c == CMD_LIST_AMBIGUOUS)
1528 /* Ambigous. Local values should be off prefixlist or called
1530 int local_allow_unknown = (last_list ? last_list->allow_unknown :
1532 const char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
1533 struct cmd_list_element *local_list =
1534 (last_list ? *(last_list->prefixlist) : list);
1536 if (local_allow_unknown < 0)
1539 return last_list; /* Found something. */
1541 return 0; /* Found nothing. */
1545 /* Report as error. */
1550 ((*line)[amb_len] && (*line)[amb_len] != ' '
1551 && (*line)[amb_len] != '\t');
1556 for (c = local_list; c; c = c->next)
1557 if (!strncmp (*line, c->name, amb_len))
1559 if (strlen (ambbuf) + strlen (c->name) + 6
1560 < (int) sizeof ambbuf)
1562 if (strlen (ambbuf))
1563 strcat (ambbuf, ", ");
1564 strcat (ambbuf, c->name);
1568 strcat (ambbuf, "..");
1572 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype,
1574 return 0; /* lint */
1579 if (c->type == set_cmd && **line != '\0' && !isspace (**line))
1580 error (_("Argument must be preceded by space."));
1582 /* We've got something. It may still not be what the caller
1583 wants (if this command *needs* a subcommand). */
1584 while (**line == ' ' || **line == '\t')
1587 if (c->prefixlist && **line && !c->allow_unknown)
1588 undef_cmd_error (c->prefixname, *line);
1590 /* Seems to be what he wants. Return it. */
1596 /* We are here presumably because an alias or command in TEXT is
1597 deprecated and a warning message should be generated. This
1598 function decodes TEXT and potentially generates a warning message
1601 Example for 'set endian big' which has a fictitious alias 'seb'.
1603 If alias wasn't used in TEXT, and the command is deprecated:
1604 "warning: 'set endian big' is deprecated."
1606 If alias was used, and only the alias is deprecated:
1607 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1609 If alias was used and command is deprecated (regardless of whether
1610 the alias itself is deprecated:
1612 "warning: 'set endian big' (seb) is deprecated."
1614 After the message has been sent, clear the appropriate flags in the
1615 command and/or the alias so the user is no longer bothered.
1619 deprecated_cmd_warning (const char *text)
1621 struct cmd_list_element *alias = NULL;
1622 struct cmd_list_element *prefix_cmd = NULL;
1623 struct cmd_list_element *cmd = NULL;
1625 if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
1626 /* Return if text doesn't evaluate to a command. */
1629 if (!((alias ? alias->deprecated_warn_user : 0)
1630 || cmd->deprecated_warn_user) )
1631 /* Return if nothing is deprecated. */
1634 printf_filtered ("Warning:");
1636 if (alias && !cmd->cmd_deprecated)
1637 printf_filtered (" '%s', an alias for the", alias->name);
1639 printf_filtered (" command '");
1642 printf_filtered ("%s", prefix_cmd->prefixname);
1644 printf_filtered ("%s", cmd->name);
1646 if (alias && cmd->cmd_deprecated)
1647 printf_filtered ("' (%s) is deprecated.\n", alias->name);
1649 printf_filtered ("' is deprecated.\n");
1652 /* If it is only the alias that is deprecated, we want to indicate
1653 the new alias, otherwise we'll indicate the new command. */
1655 if (alias && !cmd->cmd_deprecated)
1657 if (alias->replacement)
1658 printf_filtered ("Use '%s'.\n\n", alias->replacement);
1660 printf_filtered ("No alternative known.\n\n");
1664 if (cmd->replacement)
1665 printf_filtered ("Use '%s'.\n\n", cmd->replacement);
1667 printf_filtered ("No alternative known.\n\n");
1670 /* We've warned you, now we'll keep quiet. */
1672 alias->deprecated_warn_user = 0;
1674 cmd->deprecated_warn_user = 0;
1678 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1679 Return 1 on success, 0 on failure.
1681 If LINE refers to an alias, *alias will point to that alias.
1683 If LINE is a postfix command (i.e. one that is preceded by a prefix
1684 command) set *prefix_cmd.
1686 Set *cmd to point to the command LINE indicates.
1688 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1689 exist, they are NULL when we return.
1693 lookup_cmd_composition (const char *text,
1694 struct cmd_list_element **alias,
1695 struct cmd_list_element **prefix_cmd,
1696 struct cmd_list_element **cmd)
1699 int len, tmp, nfound;
1700 struct cmd_list_element *cur_list;
1701 struct cmd_list_element *prev_cmd;
1711 /* Go through as many command lists as we need to,
1712 to find the command TEXT refers to. */
1716 while (*text == ' ' || *text == '\t')
1719 /* Identify the name of the command. */
1720 len = find_command_name_length (text);
1722 /* If nothing but whitespace, return. */
1726 /* Text is the start of the first command word to lookup (and
1727 it's length is len). We copy this into a local temporary. */
1729 command = (char *) alloca (len + 1);
1730 memcpy (command, text, len);
1731 command[len] = '\0';
1736 *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1738 if (*cmd == CMD_LIST_AMBIGUOUS)
1740 return 0; /* ambiguous */
1744 return 0; /* nothing found */
1747 if ((*cmd)->cmd_pointer)
1749 /* cmd was actually an alias, we note that an alias was
1750 used (by assigning *alais) and we set *cmd. */
1752 *cmd = (*cmd)->cmd_pointer;
1754 *prefix_cmd = prev_cmd;
1756 if ((*cmd)->prefixlist)
1757 cur_list = *(*cmd)->prefixlist;
1765 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1767 /* Return a vector of char pointers which point to the different
1768 possible completions in LIST of TEXT.
1770 WORD points in the same buffer as TEXT, and completions should be
1771 returned relative to this position. For example, suppose TEXT is
1772 "foo" and we want to complete to "foobar". If WORD is "oo", return
1773 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1776 complete_on_cmdlist (struct cmd_list_element *list,
1777 completion_tracker &tracker,
1778 const char *text, const char *word,
1779 int ignore_help_classes)
1781 struct cmd_list_element *ptr;
1782 int textlen = strlen (text);
1784 int saw_deprecated_match = 0;
1786 /* We do one or two passes. In the first pass, we skip deprecated
1787 commands. If we see no matching commands in the first pass, and
1788 if we did happen to see a matching deprecated command, we do
1789 another loop to collect those. */
1790 for (pass = 0; pass < 2; ++pass)
1792 bool got_matches = false;
1794 for (ptr = list; ptr; ptr = ptr->next)
1795 if (!strncmp (ptr->name, text, textlen)
1796 && !ptr->abbrev_flag
1797 && (!ignore_help_classes || ptr->func
1798 || ptr->prefixlist))
1804 if (ptr->cmd_deprecated)
1806 saw_deprecated_match = 1;
1811 match = (char *) xmalloc (strlen (word) + strlen (ptr->name) + 1);
1813 strcpy (match, ptr->name);
1814 else if (word > text)
1816 /* Return some portion of ptr->name. */
1817 strcpy (match, ptr->name + (word - text));
1821 /* Return some of text plus ptr->name. */
1822 strncpy (match, word, text - word);
1823 match[text - word] = '\0';
1824 strcat (match, ptr->name);
1826 tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
1833 /* If we saw no matching deprecated commands in the first pass,
1835 if (!saw_deprecated_match)
1840 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1842 /* Add the different possible completions in ENUMLIST of TEXT.
1844 WORD points in the same buffer as TEXT, and completions should be
1845 returned relative to this position. For example, suppose TEXT is "foo"
1846 and we want to complete to "foobar". If WORD is "oo", return
1847 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1850 complete_on_enum (completion_tracker &tracker,
1851 const char *const *enumlist,
1852 const char *text, const char *word)
1854 int textlen = strlen (text);
1858 for (i = 0; (name = enumlist[i]) != NULL; i++)
1859 if (strncmp (name, text, textlen) == 0)
1863 match = (char *) xmalloc (strlen (word) + strlen (name) + 1);
1865 strcpy (match, name);
1866 else if (word > text)
1868 /* Return some portion of name. */
1869 strcpy (match, name + (word - text));
1873 /* Return some of text plus name. */
1874 strncpy (match, word, text - word);
1875 match[text - word] = '\0';
1876 strcat (match, name);
1878 tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
1883 /* Check function pointer. */
1885 cmd_func_p (struct cmd_list_element *cmd)
1887 return (cmd->func != NULL);
1891 /* Call the command function. */
1893 cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
1895 if (cmd_func_p (cmd))
1897 gdb::optional<scoped_restore_tmpl<int>> restore_suppress;
1899 if (cmd->suppress_notification != NULL)
1900 restore_suppress.emplace (cmd->suppress_notification, 1);
1902 (*cmd->func) (cmd, args, from_tty);
1905 error (_("Invalid command"));
1909 cli_user_command_p (struct cmd_list_element *cmd)
1911 return (cmd->theclass == class_user
1912 && (cmd->func == do_cfunc || cmd->func == do_sfunc));