GDB (xrefs)
Loading...
Searching...
No Matches
cli-decode.c
Go to the documentation of this file.
1/* Handle lists of commands, their decoding and documentation, for GDB.
2
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
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.
9
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.
14
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/>. */
17
18#include "defs.h"
19#include "symtab.h"
20#include <ctype.h>
21#include "gdbsupport/gdb_regex.h"
22#include "completer.h"
23#include "ui-out.h"
24#include "cli/cli-cmds.h"
25#include "cli/cli-decode.h"
26#include "cli/cli-style.h"
27#include "gdbsupport/gdb_optional.h"
28
29/* Prototypes for local functions. */
30
31static void undef_cmd_error (const char *, const char *);
32
34 (const char *name, cmd_list_element **list, cmd_list_element **prehook,
35 cmd_list_element **prehookee, cmd_list_element **posthook,
36 cmd_list_element **posthookee);
37
38static struct cmd_list_element *find_cmd (const char *command,
39 int len,
40 struct cmd_list_element *clist,
41 int ignore_help_classes,
42 int *nfound);
43
44static void help_cmd_list (struct cmd_list_element *list,
46 bool recurse,
47 struct ui_file *stream);
48
49static void help_all (struct ui_file *stream);
50
51static int lookup_cmd_composition_1 (const char *text,
52 struct cmd_list_element **alias,
53 struct cmd_list_element **prefix_cmd,
54 struct cmd_list_element **cmd,
55 struct cmd_list_element *cur_list);
56
57/* Look up a command whose 'subcommands' field is SUBCOMMANDS. Return the
58 command if found, otherwise return NULL. */
59
60static struct cmd_list_element *
62 cmd_list_element *list)
63{
64 struct cmd_list_element *p = NULL;
65
66 for (p = list; p != NULL; p = p->next)
67 {
68 struct cmd_list_element *q;
69
70 if (!p->is_prefix ())
71 continue;
72
73 else if (p->subcommands == subcommands)
74 {
75 /* If we found an alias, we must return the aliased
76 command. */
77 return p->is_alias () ? p->alias_target : p;
78 }
79
81 if (q != NULL)
82 return q;
83 }
84
85 return NULL;
86}
87
88static void
90 bool recurse, struct ui_file *stream);
91
92static void
93do_simple_func (const char *args, int from_tty, cmd_list_element *c)
94{
95 c->function.simple_func (args, from_tty);
96}
97
98static void
100{
101 if (simple_func == NULL)
102 cmd->func = NULL;
103 else
104 cmd->func = do_simple_func;
105
107}
108
109int
111{
112 return (cmd->func == do_simple_func
113 && cmd->function.simple_func == simple_func);
114}
115
116void
118{
119 cmd->completer = completer; /* Ok. */
120}
121
122/* See definition in commands.h. */
123
124void
127{
129}
130
131std::string
133{
134 if (!this->is_prefix ())
135 /* Not a prefix command. */
136 return "";
137
138 std::string prefixname;
139 if (this->prefix != nullptr)
140 prefixname = this->prefix->prefixname ();
141
142 prefixname += this->name;
143 prefixname += " ";
144
145 return prefixname;
146}
147
148/* See cli/cli-decode.h. */
149
150std::vector<std::string>
152{
153 std::vector<std::string> result;
154
155 if (this->prefix != nullptr)
156 result = this->prefix->command_components ();
157
158 result.emplace_back (std::string (this->name));
159 return result;
160}
161
162/* Add element named NAME.
163 Space for NAME and DOC must be allocated by the caller.
164 CLASS is the top level category into which commands are broken down
165 for "help" purposes.
166 FUN should be the function to execute the command;
167 it will get a character string as argument, with leading
168 and trailing blanks already eliminated.
169
170 DOC is a documentation string for the command.
171 Its first line should be a complete sentence.
172 It should start with ? for a command that is an abbreviation
173 or with * for a command that most users don't need to know about.
174
175 Add this command to command list *LIST.
176
177 Returns a pointer to the added command (not necessarily the head
178 of *LIST). */
179
180static struct cmd_list_element *
182 const char *doc, struct cmd_list_element **list)
183{
184 struct cmd_list_element *c = new struct cmd_list_element (name, theclass,
185 doc);
186
187 /* Turn each alias of the old command into an alias of the new
188 command. */
189 c->aliases = delete_cmd (name, list, &c->hook_pre, &c->hookee_pre,
190 &c->hook_post, &c->hookee_post);
191
192 for (cmd_list_element &alias : c->aliases)
193 alias.alias_target = c;
194
195 if (c->hook_pre)
196 c->hook_pre->hookee_pre = c;
197
198 if (c->hookee_pre)
199 c->hookee_pre->hook_pre = c;
200
201 if (c->hook_post)
202 c->hook_post->hookee_post = c;
203
204 if (c->hookee_post)
205 c->hookee_post->hook_post = c;
206
207 if (*list == NULL || strcmp ((*list)->name, name) >= 0)
208 {
209 c->next = *list;
210 *list = c;
211 }
212 else
213 {
214 cmd_list_element *p = *list;
215 while (p->next && strcmp (p->next->name, name) <= 0)
216 {
217 p = p->next;
218 }
219 c->next = p->next;
220 p->next = c;
221 }
222
223 /* Search the prefix cmd of C, and assigns it to C->prefix.
224 See also add_prefix_cmd and update_prefix_field_of_prefixed_commands. */
226 c->prefix = prefixcmd;
227
228
229 return c;
230}
231
232struct cmd_list_element *
234 const char *doc, struct cmd_list_element **list)
235{
236 cmd_list_element *result = do_add_cmd (name, theclass, doc, list);
237 result->func = NULL;
238 result->function.simple_func = NULL;
239 return result;
240}
241
242struct cmd_list_element *
245 const char *doc, struct cmd_list_element **list)
246{
247 cmd_list_element *result = do_add_cmd (name, theclass, doc, list);
248 set_cmd_simple_func (result, fun);
249 return result;
250}
251
252/* Add an element with a suppress notification to the LIST of commands. */
253
254struct cmd_list_element *
256 cmd_simple_func_ftype *fun, const char *doc,
257 struct cmd_list_element **list,
259{
260 struct cmd_list_element *element;
261
262 element = add_cmd (name, theclass, fun, doc, list);
264
265 return element;
266}
267
268
269/* Deprecates a command CMD.
270 REPLACEMENT is the name of the command which should be used in
271 place of this command, or NULL if no such command exists.
272
273 This function does not check to see if command REPLACEMENT exists
274 since gdb may not have gotten around to adding REPLACEMENT when
275 this function is called.
276
277 Returns a pointer to the deprecated command. */
278
279struct cmd_list_element *
281{
282 cmd->cmd_deprecated = 1;
283 cmd->deprecated_warn_user = 1;
284
285 if (replacement != NULL)
287 else
288 cmd->replacement = NULL;
289
290 return cmd;
291}
292
293struct cmd_list_element *
294add_alias_cmd (const char *name, cmd_list_element *target,
296 struct cmd_list_element **list)
297{
298 gdb_assert (target != nullptr);
299
300 struct cmd_list_element *c = add_cmd (name, theclass, target->doc, list);
301
302 /* If TARGET->DOC can be freed, we should make another copy. */
303 if (target->doc_allocated)
304 {
305 c->doc = xstrdup (target->doc);
306 c->doc_allocated = 1;
307 }
308 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
309 c->func = target->func;
310 c->function = target->function;
311 c->subcommands = target->subcommands;
312 c->allow_unknown = target->allow_unknown;
314 c->alias_target = target;
315 target->aliases.push_front (*c);
316
317 return c;
318}
319
320/* Update the prefix field of all sub-commands of the prefix command C.
321 We must do this when a prefix command is defined as the GDB init sequence
322 does not guarantee that a prefix command is created before its sub-commands.
323 For example, break-catch-sig.c initialization runs before breakpoint.c
324 initialization, but it is breakpoint.c that creates the "catch" command used
325 by the "catch signal" command created by break-catch-sig.c. */
326
327static void
329{
330 for (cmd_list_element *p = *c->subcommands; p != NULL; p = p->next)
331 {
332 p->prefix = c;
333
334 /* We must recursively update the prefix field to cover
335 e.g. 'info auto-load libthread-db' where the creation
336 order was:
337 libthread-db
338 auto-load
339 info
340 In such a case, when 'auto-load' was created by do_add_cmd,
341 the 'libthread-db' prefix field could not be updated, as the
342 'auto-load' command was not yet reachable by
343 lookup_cmd_for_subcommands (list, cmdlist)
344 that searches from the top level 'cmdlist'. */
345 if (p->is_prefix ())
347 }
348}
349
350
351/* Like add_cmd but adds an element for a command prefix: a name that
352 should be followed by a subcommand to be looked up in another
353 command list. SUBCOMMANDS should be the address of the variable
354 containing that list. */
355
356struct cmd_list_element *
359 const char *doc, struct cmd_list_element **subcommands,
360 int allow_unknown, struct cmd_list_element **list)
361{
362 struct cmd_list_element *c = add_cmd (name, theclass, fun, doc, list);
363
366
367 /* Now that prefix command C is defined, we need to set the prefix field
368 of all prefixed commands that were defined before C itself was defined. */
370
371 return c;
372}
373
374/* A helper function for add_basic_prefix_cmd. This is a command
375 function that just forwards to help_list. */
376
377static void
378do_prefix_cmd (const char *args, int from_tty, struct cmd_list_element *c)
379{
380 /* Look past all aliases. */
381 while (c->is_alias ())
382 c = c->alias_target;
383
384 help_list (*c->subcommands, c->prefixname ().c_str (),
386}
387
388/* See command.h. */
389
390struct cmd_list_element *
392 const char *doc, struct cmd_list_element **subcommands,
393 int allow_unknown, struct cmd_list_element **list)
394{
395 struct cmd_list_element *cmd = add_prefix_cmd (name, theclass, nullptr,
397 allow_unknown, list);
398 cmd->func = do_prefix_cmd;
399 return cmd;
400}
401
402/* A helper function for add_show_prefix_cmd. This is a command
403 function that just forwards to cmd_show_list. */
404
405static void
406do_show_prefix_cmd (const char *args, int from_tty, struct cmd_list_element *c)
407{
408 cmd_show_list (*c->subcommands, from_tty);
409}
410
411/* See command.h. */
412
413struct cmd_list_element *
415 const char *doc, struct cmd_list_element **subcommands,
416 int allow_unknown, struct cmd_list_element **list)
417{
418 struct cmd_list_element *cmd = add_prefix_cmd (name, theclass, nullptr,
420 allow_unknown, list);
422 return cmd;
423}
424
425/* See command.h. */
426
429 const char *set_doc, const char *show_doc,
430 cmd_list_element **set_subcommands_list,
431 cmd_list_element **show_subcommands_list,
432 cmd_list_element **set_list,
433 cmd_list_element **show_list)
434{
436
437 cmds.set = add_basic_prefix_cmd (name, theclass, set_doc,
438 set_subcommands_list, 0,
439 set_list);
440 cmds.show = add_show_prefix_cmd (name, theclass, show_doc,
441 show_subcommands_list, 0,
442 show_list);
443
444 return cmds;
445}
446
447/* Like ADD_PREFIX_CMD but sets the suppress_notification pointer on the
448 new command list element. */
449
450struct cmd_list_element *
452 (const char *name, enum command_class theclass,
454 const char *doc, struct cmd_list_element **subcommands,
455 int allow_unknown, struct cmd_list_element **list,
457{
458 struct cmd_list_element *element
460 allow_unknown, list);
462 return element;
463}
464
465/* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
466
467struct cmd_list_element *
469 cmd_simple_func_ftype *fun, const char *doc,
471 int allow_unknown, struct cmd_list_element **list)
472{
473 struct cmd_list_element *c = add_cmd (name, theclass, fun, doc, list);
474
477 c->abbrev_flag = 1;
478 return c;
479}
480
481/* This is an empty "simple func". */
482void
483not_just_help_class_command (const char *args, int from_tty)
484{
485}
486
487/* This is an empty cmd func. */
488
489static void
490empty_func (const char *args, int from_tty, cmd_list_element *c)
491{
492}
493
494/* Add element named NAME to command list LIST (the list for set/show
495 or some sublist thereof).
496 TYPE is set_cmd or show_cmd.
497 CLASS is as in add_cmd.
498 VAR_TYPE is the kind of thing we are setting.
499 VAR is address of the variable being controlled by this command.
500 SET_SETTING_FUNC is a pointer to an optional function callback used to set
501 the setting value.
502 GET_SETTING_FUNC is a pointer to an optional function callback used to get
503 the setting value.
504 DOC is the documentation string. */
505
506static struct cmd_list_element *
508 enum cmd_types type,
510 var_types var_type,
511 const setting::erased_args &arg,
512 const char *doc,
513 struct cmd_list_element **list)
514{
515 struct cmd_list_element *c = add_cmd (name, theclass, doc, list);
516
517 gdb_assert (type == set_cmd || type == show_cmd);
518 c->type = type;
519 c->var.emplace (var_type, arg);
520
521 /* This needs to be something besides NULL so that this isn't
522 treated as a help class. */
523 c->func = empty_func;
524 return c;
525}
526
527/* Add element named NAME to both the command SET_LIST and SHOW_LIST.
528 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
529 setting. VAR is address of the variable being controlled by this
530 command. If nullptr is given as VAR, then both SET_SETTING_FUNC and
531 GET_SETTING_FUNC must be provided. SET_SETTING_FUNC and GET_SETTING_FUNC are
532 callbacks used to access and modify the underlying property, whatever its
533 storage is. SET_FUNC and SHOW_FUNC are the callback functions (if non-NULL).
534 SET_DOC, SHOW_DOC and HELP_DOC are the documentation strings.
535
536 Return the newly created set and show commands. */
537
541 var_types var_type,
542 const setting::erased_args &args,
543 const char *set_doc, const char *show_doc,
544 const char *help_doc,
545 cmd_func_ftype *set_func,
546 show_value_ftype *show_func,
547 struct cmd_list_element **set_list,
548 struct cmd_list_element **show_list)
549{
550 struct cmd_list_element *set;
551 struct cmd_list_element *show;
552 gdb::unique_xmalloc_ptr<char> full_set_doc;
553 gdb::unique_xmalloc_ptr<char> full_show_doc;
554
555 if (help_doc != NULL)
556 {
557 full_set_doc = xstrprintf ("%s\n%s", set_doc, help_doc);
558 full_show_doc = xstrprintf ("%s\n%s", show_doc, help_doc);
559 }
560 else
561 {
562 full_set_doc = make_unique_xstrdup (set_doc);
563 full_show_doc = make_unique_xstrdup (show_doc);
564 }
565 set = add_set_or_show_cmd (name, set_cmd, theclass, var_type, args,
566 full_set_doc.release (), set_list);
567 set->doc_allocated = 1;
568
569 if (set_func != NULL)
570 set->func = set_func;
571
572 show = add_set_or_show_cmd (name, show_cmd, theclass, var_type, args,
573 full_show_doc.release (), show_list);
574 show->doc_allocated = 1;
575 show->show_value_func = show_func;
576 /* Disable the default symbol completer. Doesn't make much sense
577 for the "show" command to complete on anything. */
578 set_cmd_completer (show, nullptr);
579
580 return {set, show};
581}
582
583template<typename T>
587 var_types var_type, T *var,
588 const char *set_doc, const char *show_doc,
589 const char *help_doc,
590 typename setting_func_types<T>::set set_setting_func,
591 typename setting_func_types<T>::get get_setting_func,
592 cmd_func_ftype *set_func,
593 show_value_ftype *show_func,
594 struct cmd_list_element **set_list,
595 struct cmd_list_element **show_list)
596{
597 auto erased_args
598 = setting::erase_args (var_type, var,
599 set_setting_func, get_setting_func);
600
602 theclass,
603 var_type, erased_args,
604 set_doc, show_doc,
605 help_doc,
606 set_func,
607 show_func,
608 set_list,
609 show_list);
610}
611
612/* Add element named NAME to command list LIST (the list for set or
613 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
614 of strings which may follow NAME. VAR is address of the variable
615 which will contain the matching string (from ENUMLIST). */
616
620 const char *const *enumlist,
621 const char **var,
622 const char *set_doc,
623 const char *show_doc,
624 const char *help_doc,
625 cmd_func_ftype *set_func,
626 show_value_ftype *show_func,
627 struct cmd_list_element **set_list,
628 struct cmd_list_element **show_list)
629{
630 /* We require *VAR to be initialized before this call, and
631 furthermore it must be == to one of the values in ENUMLIST. */
632 gdb_assert (var != nullptr && *var != nullptr);
633 for (int i = 0; ; ++i)
634 {
635 gdb_assert (enumlist[i] != nullptr);
636 if (*var == enumlist[i])
637 break;
638 }
639
640 set_show_commands commands
641 = add_setshow_cmd_full<const char *> (name, theclass, var_enum, var,
642 set_doc, show_doc, help_doc,
643 nullptr, nullptr, set_func,
644 show_func, set_list, show_list);
645 commands.set->enums = enumlist;
646 return commands;
647}
648
649/* Same as above but using a getter and a setter function instead of a pointer
650 to a global storage buffer. */
651
654 const char *const *enumlist, const char *set_doc,
655 const char *show_doc, const char *help_doc,
658 show_value_ftype *show_func,
659 cmd_list_element **set_list,
660 cmd_list_element **show_list)
661{
662 auto cmds = add_setshow_cmd_full<const char *> (name, theclass, var_enum,
663 nullptr, set_doc, show_doc,
664 help_doc, set_func, get_func,
665 nullptr, show_func, set_list,
666 show_list);
667
668 cmds.set->enums = enumlist;
669
670 return cmds;
671}
672
673/* See cli-decode.h. */
674const char * const auto_boolean_enums[] = { "on", "off", "auto", NULL };
675
676/* Add an auto-boolean command named NAME to both the set and show
677 command list lists. CLASS is as in add_cmd. VAR is address of the
678 variable which will contain the value. DOC is the documentation
679 string. FUNC is the corresponding callback. */
680
684 enum auto_boolean *var,
685 const char *set_doc, const char *show_doc,
686 const char *help_doc,
687 cmd_func_ftype *set_func,
688 show_value_ftype *show_func,
689 struct cmd_list_element **set_list,
690 struct cmd_list_element **show_list)
691{
692 set_show_commands commands
693 = add_setshow_cmd_full<enum auto_boolean> (name, theclass, var_auto_boolean,
694 var, set_doc, show_doc, help_doc,
695 nullptr, nullptr, set_func,
696 show_func, set_list, show_list);
697
698 commands.set->enums = auto_boolean_enums;
699
700 return commands;
701}
702
703/* Same as above but using a getter and a setter function instead of a pointer
704 to a global storage buffer. */
705
708 const char *set_doc, const char *show_doc,
709 const char *help_doc,
712 show_value_ftype *show_func,
713 cmd_list_element **set_list,
714 cmd_list_element **show_list)
715{
716 auto cmds = add_setshow_cmd_full<enum auto_boolean> (name, theclass,
718 nullptr, set_doc,
719 show_doc, help_doc,
720 set_func, get_func,
721 nullptr, show_func,
722 set_list, show_list);
723
724 cmds.set->enums = auto_boolean_enums;
725
726 return cmds;
727}
728
729/* See cli-decode.h. */
730const char * const boolean_enums[] = { "on", "off", NULL };
731
732/* Add element named NAME to both the set and show command LISTs (the
733 list for set/show or some sublist thereof). CLASS is as in
734 add_cmd. VAR is address of the variable which will contain the
735 value. SET_DOC and SHOW_DOC are the documentation strings.
736 Returns the new command element. */
737
740 const char *set_doc, const char *show_doc,
741 const char *help_doc,
742 cmd_func_ftype *set_func,
743 show_value_ftype *show_func,
744 struct cmd_list_element **set_list,
745 struct cmd_list_element **show_list)
746{
747 set_show_commands commands
748 = add_setshow_cmd_full<bool> (name, theclass, var_boolean, var,
749 set_doc, show_doc, help_doc,
750 nullptr, nullptr, set_func, show_func,
751 set_list, show_list);
752
753 commands.set->enums = boolean_enums;
754
755 return commands;
756}
757
758/* Same as above but using a getter and a setter function instead of a pointer
759 to a global storage buffer. */
760
763 const char *set_doc, const char *show_doc,
764 const char *help_doc,
767 show_value_ftype *show_func,
768 cmd_list_element **set_list,
769 cmd_list_element **show_list)
770{
771 auto cmds = add_setshow_cmd_full<bool> (name, theclass, var_boolean, nullptr,
772 set_doc, show_doc, help_doc,
773 set_func, get_func, nullptr,
774 show_func, set_list, show_list);
775
776 cmds.set->enums = boolean_enums;
777
778 return cmds;
779}
780
781/* Add element named NAME to both the set and show command LISTs (the
782 list for set/show or some sublist thereof). */
783
786 std::string *var,
787 const char *set_doc, const char *show_doc,
788 const char *help_doc,
789 cmd_func_ftype *set_func,
790 show_value_ftype *show_func,
791 struct cmd_list_element **set_list,
792 struct cmd_list_element **show_list)
793{
794 set_show_commands commands
795 = add_setshow_cmd_full<std::string> (name, theclass, var_filename, var,
796 set_doc, show_doc, help_doc,
797 nullptr, nullptr, set_func,
798 show_func, set_list, show_list);
799
801
802 return commands;
803}
804
805/* Same as above but using a getter and a setter function instead of a pointer
806 to a global storage buffer. */
807
810 const char *set_doc, const char *show_doc,
811 const char *help_doc,
814 show_value_ftype *show_func,
815 cmd_list_element **set_list,
816 cmd_list_element **show_list)
817{
818 auto cmds = add_setshow_cmd_full<std::string> (name, theclass, var_filename,
819 nullptr, set_doc, show_doc,
820 help_doc, set_func, get_func,
821 nullptr, show_func, set_list,
822 show_list);
823
825
826 return cmds;
827}
828
829/* Add element named NAME to both the set and show command LISTs (the
830 list for set/show or some sublist thereof). */
831
834 std::string *var,
835 const char *set_doc, const char *show_doc,
836 const char *help_doc,
837 cmd_func_ftype *set_func,
838 show_value_ftype *show_func,
839 struct cmd_list_element **set_list,
840 struct cmd_list_element **show_list)
841{
842 set_show_commands commands
843 = add_setshow_cmd_full<std::string> (name, theclass, var_string, var,
844 set_doc, show_doc, help_doc,
845 nullptr, nullptr, set_func,
846 show_func, set_list, show_list);
847
848 /* Disable the default symbol completer. */
849 set_cmd_completer (commands.set, nullptr);
850
851 return commands;
852}
853
854/* Same as above but using a getter and a setter function instead of a pointer
855 to a global storage buffer. */
856
859 const char *set_doc, const char *show_doc,
860 const char *help_doc,
863 show_value_ftype *show_func,
864 cmd_list_element **set_list,
865 cmd_list_element **show_list)
866{
867 auto cmds = add_setshow_cmd_full<std::string> (name, theclass, var_string,
868 nullptr, set_doc, show_doc,
869 help_doc, set_func, get_func,
870 nullptr, show_func, set_list,
871 show_list);
872
873 /* Disable the default symbol completer. */
874 set_cmd_completer (cmds.set, nullptr);
875
876 return cmds;
877}
878
879/* Add element named NAME to both the set and show command LISTs (the
880 list for set/show or some sublist thereof). */
881
884 std::string *var,
885 const char *set_doc, const char *show_doc,
886 const char *help_doc,
887 cmd_func_ftype *set_func,
888 show_value_ftype *show_func,
889 struct cmd_list_element **set_list,
890 struct cmd_list_element **show_list)
891{
892 set_show_commands commands
893 = add_setshow_cmd_full<std::string> (name, theclass, var_string_noescape,
894 var, set_doc, show_doc, help_doc,
895 nullptr, nullptr, set_func, show_func,
896 set_list, show_list);
897
898 /* Disable the default symbol completer. */
899 set_cmd_completer (commands.set, nullptr);
900
901 return commands;
902}
903
904/* Same as above but using a getter and a setter function instead of a pointer
905 to a global storage buffer. */
906
909 const char *set_doc, const char *show_doc,
910 const char *help_doc,
913 show_value_ftype *show_func,
914 cmd_list_element **set_list,
915 cmd_list_element **show_list)
916{
917 auto cmds = add_setshow_cmd_full<std::string> (name, theclass,
918 var_string_noescape, nullptr,
919 set_doc, show_doc, help_doc,
920 set_func, get_func,
921 nullptr, show_func, set_list,
922 show_list);
923
924 /* Disable the default symbol completer. */
925 set_cmd_completer (cmds.set, nullptr);
926
927 return cmds;
928}
929
930/* Add element named NAME to both the set and show command LISTs (the
931 list for set/show or some sublist thereof). */
932
935 std::string *var,
936 const char *set_doc, const char *show_doc,
937 const char *help_doc,
938 cmd_func_ftype *set_func,
939 show_value_ftype *show_func,
940 struct cmd_list_element **set_list,
941 struct cmd_list_element **show_list)
942{
943 set_show_commands commands
944 = add_setshow_cmd_full<std::string> (name, theclass, var_optional_filename,
945 var, set_doc, show_doc, help_doc,
946 nullptr, nullptr, set_func, show_func,
947 set_list, show_list);
948
950
951 return commands;
952}
953
954/* Same as above but using a getter and a setter function instead of a pointer
955 to a global storage buffer. */
956
959 const char *set_doc, const char *show_doc,
960 const char *help_doc,
963 show_value_ftype *show_func,
964 cmd_list_element **set_list,
965 cmd_list_element **show_list)
966{
967 auto cmds =
968 add_setshow_cmd_full<std::string> (name, theclass, var_optional_filename,
969 nullptr, set_doc, show_doc, help_doc,
970 set_func, get_func, nullptr, show_func,
971 set_list,show_list);
972
974
975 return cmds;
976}
977
978/* Completes on literal "unlimited". Used by integer commands that
979 support a special "unlimited" value. */
980
981static void
983 completion_tracker &tracker,
984 const char *text, const char *word)
985{
986 static const char * const keywords[] =
987 {
988 "unlimited",
989 NULL,
990 };
991
992 if (*text == '\0')
993 tracker.add_completion (make_unique_xstrdup ("NUMBER"));
994 complete_on_enum (tracker, keywords, text, word);
995}
996
997/* Add element named NAME to both the set and show command LISTs (the
998 list for set/show or some sublist thereof). CLASS is as in
999 add_cmd. VAR is address of the variable which will contain the
1000 value. SET_DOC and SHOW_DOC are the documentation strings. This
1001 function is only used in Python API. Please don't use it elsewhere. */
1002
1005 int *var,
1006 const char *set_doc, const char *show_doc,
1007 const char *help_doc,
1008 cmd_func_ftype *set_func,
1009 show_value_ftype *show_func,
1010 struct cmd_list_element **set_list,
1011 struct cmd_list_element **show_list)
1012{
1013 set_show_commands commands
1014 = add_setshow_cmd_full<int> (name, theclass, var_integer, var,
1015 set_doc, show_doc, help_doc,
1016 nullptr, nullptr, set_func,
1017 show_func, set_list, show_list);
1018
1020
1021 return commands;
1022}
1023
1024/* Same as above but using a getter and a setter function instead of a pointer
1025 to a global storage buffer. */
1026
1029 const char *set_doc, const char *show_doc,
1030 const char *help_doc,
1033 show_value_ftype *show_func,
1034 cmd_list_element **set_list,
1035 cmd_list_element **show_list)
1036{
1037 auto cmds = add_setshow_cmd_full<int> (name, theclass, var_integer, nullptr,
1038 set_doc, show_doc, help_doc, set_func,
1039 get_func, nullptr, show_func, set_list,
1040 show_list);
1041
1043
1044 return cmds;
1045}
1046
1047/* Add element named NAME to both the set and show command LISTs (the
1048 list for set/show or some sublist thereof). CLASS is as in
1049 add_cmd. VAR is address of the variable which will contain the
1050 value. SET_DOC and SHOW_DOC are the documentation strings. */
1051
1054 unsigned int *var,
1055 const char *set_doc, const char *show_doc,
1056 const char *help_doc,
1057 cmd_func_ftype *set_func,
1058 show_value_ftype *show_func,
1059 struct cmd_list_element **set_list,
1060 struct cmd_list_element **show_list)
1061{
1062 set_show_commands commands
1063 = add_setshow_cmd_full<unsigned int> (name, theclass, var_uinteger, var,
1064 set_doc, show_doc, help_doc,
1065 nullptr, nullptr, set_func,
1066 show_func, set_list, show_list);
1067
1069
1070 return commands;
1071}
1072
1073/* Same as above but using a getter and a setter function instead of a pointer
1074 to a global storage buffer. */
1075
1078 const char *set_doc, const char *show_doc,
1079 const char *help_doc,
1082 show_value_ftype *show_func,
1083 cmd_list_element **set_list,
1084 cmd_list_element **show_list)
1085{
1086 auto cmds = add_setshow_cmd_full<unsigned int> (name, theclass, var_uinteger,
1087 nullptr, set_doc, show_doc,
1088 help_doc, set_func, get_func,
1089 nullptr, show_func, set_list,
1090 show_list);
1091
1093
1094 return cmds;
1095}
1096
1097/* Add element named NAME to both the set and show command LISTs (the
1098 list for set/show or some sublist thereof). CLASS is as in
1099 add_cmd. VAR is address of the variable which will contain the
1100 value. SET_DOC and SHOW_DOC are the documentation strings. */
1101
1104 int *var,
1105 const char *set_doc, const char *show_doc,
1106 const char *help_doc,
1107 cmd_func_ftype *set_func,
1108 show_value_ftype *show_func,
1109 struct cmd_list_element **set_list,
1110 struct cmd_list_element **show_list)
1111{
1112 return add_setshow_cmd_full<int> (name, theclass, var_zinteger, var,
1113 set_doc, show_doc, help_doc,
1114 nullptr, nullptr, set_func,
1115 show_func, set_list, show_list);
1116}
1117
1118/* Same as above but using a getter and a setter function instead of a pointer
1119 to a global storage buffer. */
1120
1123 const char *set_doc, const char *show_doc,
1124 const char *help_doc,
1127 show_value_ftype *show_func,
1128 cmd_list_element **set_list,
1129 cmd_list_element **show_list)
1130{
1131 return add_setshow_cmd_full<int> (name, theclass, var_zinteger, nullptr,
1132 set_doc, show_doc, help_doc, set_func,
1133 get_func, nullptr, show_func, set_list,
1134 show_list);
1135}
1136
1140 int *var,
1141 const char *set_doc,
1142 const char *show_doc,
1143 const char *help_doc,
1144 cmd_func_ftype *set_func,
1145 show_value_ftype *show_func,
1146 struct cmd_list_element **set_list,
1147 struct cmd_list_element **show_list)
1148{
1149 set_show_commands commands
1150 = add_setshow_cmd_full<int> (name, theclass, var_zuinteger_unlimited, var,
1151 set_doc, show_doc, help_doc, nullptr,
1152 nullptr, set_func, show_func, set_list,
1153 show_list);
1154
1156
1157 return commands;
1158}
1159
1160/* Same as above but using a getter and a setter function instead of a pointer
1161 to a global storage buffer. */
1162
1165 const char *set_doc, const char *show_doc,
1166 const char *help_doc,
1169 show_value_ftype *show_func,
1170 cmd_list_element **set_list,
1171 cmd_list_element **show_list)
1172{
1173 auto cmds
1174 = add_setshow_cmd_full<int> (name, theclass, var_zuinteger_unlimited,
1175 nullptr, set_doc, show_doc, help_doc, set_func,
1176 get_func, nullptr, show_func, set_list,
1177 show_list);
1178
1180
1181 return cmds;
1182}
1183
1184/* Add element named NAME to both the set and show command LISTs (the
1185 list for set/show or some sublist thereof). CLASS is as in
1186 add_cmd. VAR is address of the variable which will contain the
1187 value. SET_DOC and SHOW_DOC are the documentation strings. */
1188
1191 unsigned int *var,
1192 const char *set_doc, const char *show_doc,
1193 const char *help_doc,
1194 cmd_func_ftype *set_func,
1195 show_value_ftype *show_func,
1196 struct cmd_list_element **set_list,
1197 struct cmd_list_element **show_list)
1198{
1199 return add_setshow_cmd_full<unsigned int> (name, theclass, var_zuinteger,
1200 var, set_doc, show_doc, help_doc,
1201 nullptr, nullptr, set_func,
1202 show_func, set_list, show_list);
1203}
1204
1205/* Same as above but using a getter and a setter function instead of a pointer
1206 to a global storage buffer. */
1207
1210 const char *set_doc, const char *show_doc,
1211 const char *help_doc,
1214 show_value_ftype *show_func,
1215 cmd_list_element **set_list,
1216 cmd_list_element **show_list)
1217{
1218 return add_setshow_cmd_full<unsigned int> (name, theclass, var_zuinteger,
1219 nullptr, set_doc, show_doc,
1220 help_doc, set_func, get_func,
1221 nullptr, show_func, set_list,
1222 show_list);
1223}
1224
1225/* Remove the command named NAME from the command list. Return the list
1226 commands which were aliased to the deleted command. The various *HOOKs are
1227 set to the pre- and post-hook commands for the deleted command. If the
1228 command does not have a hook, the corresponding out parameter is set to
1229 NULL. */
1230
1232delete_cmd (const char *name, struct cmd_list_element **list,
1233 struct cmd_list_element **prehook,
1234 struct cmd_list_element **prehookee,
1235 struct cmd_list_element **posthook,
1236 struct cmd_list_element **posthookee)
1237{
1238 struct cmd_list_element *iter;
1239 struct cmd_list_element **previous_chain_ptr;
1241
1242 *prehook = NULL;
1243 *prehookee = NULL;
1244 *posthook = NULL;
1245 *posthookee = NULL;
1246 previous_chain_ptr = list;
1247
1248 for (iter = *previous_chain_ptr; iter; iter = *previous_chain_ptr)
1249 {
1250 if (strcmp (iter->name, name) == 0)
1251 {
1252 if (iter->destroyer)
1253 iter->destroyer (iter, iter->context ());
1254
1255 if (iter->hookee_pre)
1256 iter->hookee_pre->hook_pre = 0;
1257 *prehook = iter->hook_pre;
1258 *prehookee = iter->hookee_pre;
1259 if (iter->hookee_post)
1260 iter->hookee_post->hook_post = 0;
1261 *posthook = iter->hook_post;
1262 *posthookee = iter->hookee_post;
1263
1264 /* Update the link. */
1265 *previous_chain_ptr = iter->next;
1266
1267 aliases = std::move (iter->aliases);
1268
1269 /* If this command was an alias, remove it from the list of
1270 aliases. */
1271 if (iter->is_alias ())
1272 {
1273 auto it = iter->alias_target->aliases.iterator_to (*iter);
1274 iter->alias_target->aliases.erase (it);
1275 }
1276
1277 delete iter;
1278
1279 /* We won't see another command with the same name. */
1280 break;
1281 }
1282 else
1283 previous_chain_ptr = &iter->next;
1284 }
1285
1286 return aliases;
1287}
1288
1289/* Shorthands to the commands above. */
1290
1291/* Add an element to the list of info subcommands. */
1292
1293struct cmd_list_element *
1294add_info (const char *name, cmd_simple_func_ftype *fun, const char *doc)
1295{
1296 return add_cmd (name, class_info, fun, doc, &infolist);
1297}
1298
1299/* Add an alias to the list of info subcommands. */
1300
1303{
1304 return add_alias_cmd (name, target, class_run, abbrev_flag, &infolist);
1305}
1306
1307/* Add an element to the list of commands. */
1308
1309struct cmd_list_element *
1312 const char *doc)
1313{
1314 return add_cmd (name, theclass, fun, doc, &cmdlist);
1315}
1316
1317/* Add an alias or abbreviation command to the list of commands.
1318 For aliases predefined by GDB (such as bt), THECLASS must be
1319 different of class_alias, as class_alias is used to identify
1320 user defined aliases. */
1321
1325{
1326 return add_alias_cmd (name, target, theclass, abbrev_flag, &cmdlist);
1327}
1328
1329/* Add an element with a suppress notification to the list of commands. */
1330
1331struct cmd_list_element *
1333 cmd_simple_func_ftype *fun, const char *doc,
1335{
1338}
1339
1340/* Print the prefix of C followed by name of C in title style. */
1341
1342static void
1344{
1345 std::string prefixname
1346 = c.prefix == nullptr ? "" : c.prefix->prefixname ();
1347
1348 fprintf_styled (stream, title_style.style (), "%s%s",
1349 prefixname.c_str (), c.name);
1350}
1351
1352/* True if ALIAS has a user-defined documentation. */
1353
1354static bool
1356{
1357 gdb_assert (alias.is_alias ());
1358 /* Alias is user documented if it has an allocated documentation
1359 that differs from the aliased command. */
1360 return (alias.doc_allocated
1361 && strcmp (alias.doc, alias.alias_target->doc) != 0);
1362}
1363
1364/* Print the definition of alias C using title style for alias
1365 and aliased command. */
1366
1367static void
1369 struct ui_file *stream)
1370{
1371 gdb_assert (c.is_alias ());
1372 gdb_puts (" alias ", stream);
1373 fput_command_name_styled (c, stream);
1374 gdb_printf (stream, " = ");
1376 gdb_printf (stream, " %s\n", c.default_args.c_str ());
1377}
1378
1379/* Print the definition of CMD aliases not deprecated and having default args
1380 and not specifically documented by the user. */
1381
1382static void
1384 struct ui_file *stream)
1385{
1386 for (const cmd_list_element &alias : cmd.aliases)
1387 if (!alias.cmd_deprecated
1389 && !alias.default_args.empty ())
1391}
1392
1393/* If C has one or more aliases, style print the name of C and the name of its
1394 aliases not documented specifically by the user, separated by commas.
1395 If ALWAYS_FPUT_C_NAME, print the name of C even if it has no aliases.
1396 If one or more names are printed, POSTFIX is printed after the last name.
1397*/
1398
1399static void
1401 bool always_fput_c_name, const char *postfix,
1402 struct ui_file *stream)
1403{
1404 /* First, check if we are going to print something. That is, either if
1405 ALWAYS_FPUT_C_NAME is true or if there exists at least one non-deprecated
1406 alias not documented specifically by the user. */
1407
1408 auto print_alias = [] (const cmd_list_element &alias)
1409 {
1410 return !alias.cmd_deprecated && !user_documented_alias (alias);
1411 };
1412
1413 bool print_something = always_fput_c_name;
1414 if (!print_something)
1415 for (const cmd_list_element &alias : c.aliases)
1416 {
1417 if (!print_alias (alias))
1418 continue;
1419
1420 print_something = true;
1421 break;
1422 }
1423
1424 if (print_something)
1425 fput_command_name_styled (c, stream);
1426
1427 for (const cmd_list_element &alias : c.aliases)
1428 {
1429 if (!print_alias (alias))
1430 continue;
1431
1432 gdb_puts (", ", stream);
1433 stream->wrap_here (3);
1435 }
1436
1437 if (print_something)
1438 gdb_puts (postfix, stream);
1439}
1440
1441/* If VERBOSE, print the full help for command C and highlight the
1442 documentation parts matching HIGHLIGHT,
1443 otherwise print only one-line help for command C. */
1444
1445static void
1447 bool verbose, compiled_regex &highlight,
1448 struct ui_file *stream)
1449{
1450 /* When printing the full documentation, add a line to separate
1451 this documentation from the previous command help, in the likely
1452 case that apropos finds several commands. */
1453 if (verbose)
1454 gdb_puts ("\n", stream);
1455
1457 verbose ? "" : " -- ", stream);
1458 if (verbose)
1459 {
1460 gdb_puts ("\n", stream);
1462 fputs_highlighted (c.doc, highlight, stream);
1463 gdb_puts ("\n", stream);
1464 }
1465 else
1466 {
1467 print_doc_line (stream, c.doc, false);
1468 gdb_puts ("\n", stream);
1470 }
1471}
1472
1473/* Recursively walk the commandlist structures, and print out the
1474 documentation of commands that match our regex in either their
1475 name, or their documentation.
1476 If VERBOSE, prints the complete documentation and highlight the
1477 documentation parts matching REGEX, otherwise prints only
1478 the first line.
1479*/
1480void
1481apropos_cmd (struct ui_file *stream,
1482 struct cmd_list_element *commandlist,
1483 bool verbose, compiled_regex &regex, const char *prefix)
1484{
1485 struct cmd_list_element *c;
1486 int returnvalue;
1487
1488 /* Walk through the commands. */
1489 for (c=commandlist;c;c=c->next)
1490 {
1491 if (c->is_alias () && !user_documented_alias (*c))
1492 {
1493 /* Command aliases/abbreviations not specifically documented by the
1494 user are skipped to ensure we print the doc of a command only once,
1495 when encountering the aliased command. */
1496 continue;
1497 }
1498
1499 returnvalue = -1; /* Needed to avoid double printing. */
1500 if (c->name != NULL)
1501 {
1502 size_t name_len = strlen (c->name);
1503
1504 /* Try to match against the name. */
1505 returnvalue = regex.search (c->name, name_len, 0, name_len, NULL);
1506 if (returnvalue >= 0)
1507 print_doc_of_command (*c, prefix, verbose, regex, stream);
1508
1509 /* Try to match against the name of the aliases. */
1510 for (const cmd_list_element &alias : c->aliases)
1511 {
1512 name_len = strlen (alias.name);
1513 returnvalue = regex.search (alias.name, name_len, 0, name_len, NULL);
1514 if (returnvalue >= 0)
1515 {
1516 print_doc_of_command (*c, prefix, verbose, regex, stream);
1517 break;
1518 }
1519 }
1520 }
1521 if (c->doc != NULL && returnvalue < 0)
1522 {
1523 size_t doc_len = strlen (c->doc);
1524
1525 /* Try to match against documentation. */
1526 if (regex.search (c->doc, doc_len, 0, doc_len, NULL) >= 0)
1527 print_doc_of_command (*c, prefix, verbose, regex, stream);
1528 }
1529 /* Check if this command has subcommands. */
1530 if (c->is_prefix ())
1531 {
1532 /* Recursively call ourselves on the subcommand list,
1533 passing the right prefix in. */
1534 apropos_cmd (stream, *c->subcommands, verbose, regex,
1535 c->prefixname ().c_str ());
1536 }
1537 }
1538}
1539
1540/* This command really has to deal with two things:
1541 1) I want documentation on *this string* (usually called by
1542 "help commandname").
1543
1544 2) I want documentation on *this list* (usually called by giving a
1545 command that requires subcommands. Also called by saying just
1546 "help".)
1547
1548 I am going to split this into two separate commands, help_cmd and
1549 help_list. */
1550
1551void
1552help_cmd (const char *command, struct ui_file *stream)
1553{
1554 struct cmd_list_element *c, *alias, *prefix_cmd, *c_cmd;
1555
1556 if (!command)
1557 {
1558 help_list (cmdlist, "", all_classes, stream);
1559 return;
1560 }
1561
1562 if (strcmp (command, "all") == 0)
1563 {
1564 help_all (stream);
1565 return;
1566 }
1567
1568 const char *orig_command = command;
1569 c = lookup_cmd (&command, cmdlist, "", NULL, 0, 0);
1570
1571 if (c == 0)
1572 return;
1573
1574 lookup_cmd_composition (orig_command, &alias, &prefix_cmd, &c_cmd);
1575
1576 /* There are three cases here.
1577 If c->subcommands is nonzero, we have a prefix command.
1578 Print its documentation, then list its subcommands.
1579
1580 If c->func is non NULL, we really have a command. Print its
1581 documentation and return.
1582
1583 If c->func is NULL, we have a class name. Print its
1584 documentation (as if it were a command) and then set class to the
1585 number of this class so that the commands in the class will be
1586 listed. */
1587
1588 if (alias == nullptr || !user_documented_alias (*alias))
1589 {
1590 /* Case of a normal command, or an alias not explictly
1591 documented by the user. */
1592 /* If the user asked 'help somecommand' and there is no alias,
1593 the false indicates to not output the (single) command name. */
1594 fput_command_names_styled (*c, false, "\n", stream);
1595 fput_aliases_definition_styled (*c, stream);
1596 gdb_puts (c->doc, stream);
1597 }
1598 else
1599 {
1600 /* Case of an alias explictly documented by the user.
1601 Only output the alias definition and its explicit documentation. */
1603 fput_command_names_styled (*alias, false, "\n", stream);
1604 gdb_puts (alias->doc, stream);
1605 }
1606 gdb_puts ("\n", stream);
1607
1608 if (!c->is_prefix () && !c->is_command_class_help ())
1609 return;
1610
1611 gdb_printf (stream, "\n");
1612
1613 /* If this is a prefix command, print it's subcommands. */
1614 if (c->is_prefix ())
1615 help_list (*c->subcommands, c->prefixname ().c_str (),
1616 all_commands, stream);
1617
1618 /* If this is a class name, print all of the commands in the class. */
1619 if (c->is_command_class_help ())
1620 help_list (cmdlist, "", c->theclass, stream);
1621
1622 if (c->hook_pre || c->hook_post)
1623 gdb_printf (stream,
1624 "\nThis command has a hook (or hooks) defined:\n");
1625
1626 if (c->hook_pre)
1627 gdb_printf (stream,
1628 "\tThis command is run after : %s (pre hook)\n",
1629 c->hook_pre->name);
1630 if (c->hook_post)
1631 gdb_printf (stream,
1632 "\tThis command is run before : %s (post hook)\n",
1633 c->hook_post->name);
1634}
1635
1636/*
1637 * Get a specific kind of help on a command list.
1638 *
1639 * LIST is the list.
1640 * CMDTYPE is the prefix to use in the title string.
1641 * CLASS is the class with which to list the nodes of this list (see
1642 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
1643 * everything, ALL_CLASSES for just classes, and non-negative for only things
1644 * in a specific class.
1645 * and STREAM is the output stream on which to print things.
1646 * If you call this routine with a class >= 0, it recurses.
1647 */
1648void
1649help_list (struct cmd_list_element *list, const char *cmdtype,
1650 enum command_class theclass, struct ui_file *stream)
1651{
1652 int len;
1653 char *cmdtype1, *cmdtype2;
1654
1655 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
1656 */
1657 len = strlen (cmdtype);
1658 cmdtype1 = (char *) alloca (len + 1);
1659 cmdtype1[0] = 0;
1660 cmdtype2 = (char *) alloca (len + 4);
1661 cmdtype2[0] = 0;
1662 if (len)
1663 {
1664 cmdtype1[0] = ' ';
1665 memcpy (cmdtype1 + 1, cmdtype, len - 1);
1666 cmdtype1[len] = 0;
1667 memcpy (cmdtype2, cmdtype, len - 1);
1668 strcpy (cmdtype2 + len - 1, " sub");
1669 }
1670
1671 if (theclass == all_classes)
1672 gdb_printf (stream, "List of classes of %scommands:\n\n", cmdtype2);
1673 else
1674 gdb_printf (stream, "List of %scommands:\n\n", cmdtype2);
1675
1676 help_cmd_list (list, theclass, theclass >= 0, stream);
1677
1678 if (theclass == all_classes)
1679 {
1680 gdb_printf (stream, "\n\
1681Type \"help%s\" followed by a class name for a list of commands in ",
1682 cmdtype1);
1683 stream->wrap_here (0);
1684 gdb_printf (stream, "that class.");
1685
1686 gdb_printf (stream, "\n\
1687Type \"help all\" for the list of all commands.");
1688 }
1689
1690 gdb_printf (stream, "\nType \"help%s\" followed by %scommand name ",
1691 cmdtype1, cmdtype2);
1692 stream->wrap_here (0);
1693 gdb_puts ("for ", stream);
1694 stream->wrap_here (0);
1695 gdb_puts ("full ", stream);
1696 stream->wrap_here (0);
1697 gdb_puts ("documentation.\n", stream);
1698 gdb_puts ("Type \"apropos word\" to search "
1699 "for commands related to \"word\".\n", stream);
1700 gdb_puts ("Type \"apropos -v word\" for full documentation", stream);
1701 stream->wrap_here (0);
1702 gdb_puts (" of commands related to \"word\".\n", stream);
1703 gdb_puts ("Command name abbreviations are allowed if unambiguous.\n",
1704 stream);
1705}
1706
1707static void
1708help_all (struct ui_file *stream)
1709{
1710 struct cmd_list_element *c;
1711 int seen_unclassified = 0;
1712
1713 for (c = cmdlist; c; c = c->next)
1714 {
1715 if (c->abbrev_flag)
1716 continue;
1717 /* If this is a class name, print all of the commands in the
1718 class. */
1719
1720 if (c->is_command_class_help ())
1721 {
1722 gdb_printf (stream, "\nCommand class: %s\n\n", c->name);
1723 help_cmd_list (cmdlist, c->theclass, true, stream);
1724 }
1725 }
1726
1727 /* While it's expected that all commands are in some class,
1728 as a safety measure, we'll print commands outside of any
1729 class at the end. */
1730
1731 for (c = cmdlist; c; c = c->next)
1732 {
1733 if (c->abbrev_flag)
1734 continue;
1735
1736 if (c->theclass == no_class)
1737 {
1738 if (!seen_unclassified)
1739 {
1740 gdb_printf (stream, "\nUnclassified commands\n\n");
1741 seen_unclassified = 1;
1742 }
1743 print_help_for_command (*c, true, stream);
1744 }
1745 }
1746
1747}
1748
1749/* See cli-decode.h. */
1750
1751void
1752print_doc_line (struct ui_file *stream, const char *str,
1753 bool for_value_prefix)
1754{
1755 static char *line_buffer = 0;
1756 static int line_size;
1757 const char *p;
1758
1759 if (!line_buffer)
1760 {
1761 line_size = 80;
1762 line_buffer = (char *) xmalloc (line_size);
1763 }
1764
1765 /* Searches for the first end of line or the end of STR. */
1766 p = str;
1767 while (*p && *p != '\n')
1768 p++;
1769 if (p - str > line_size - 1)
1770 {
1771 line_size = p - str + 1;
1772 xfree (line_buffer);
1773 line_buffer = (char *) xmalloc (line_size);
1774 }
1775 strncpy (line_buffer, str, p - str);
1776 if (for_value_prefix)
1777 {
1778 if (islower (line_buffer[0]))
1779 line_buffer[0] = toupper (line_buffer[0]);
1780 gdb_assert (p > str);
1781 if (line_buffer[p - str - 1] == '.')
1782 line_buffer[p - str - 1] = '\0';
1783 else
1784 line_buffer[p - str] = '\0';
1785 }
1786 else
1787 line_buffer[p - str] = '\0';
1788 gdb_puts (line_buffer, stream);
1789}
1790
1791/* Print one-line help for command C.
1792 If RECURSE is non-zero, also print one-line descriptions
1793 of all prefixed subcommands. */
1794static void
1796 bool recurse, struct ui_file *stream)
1797{
1798 fput_command_names_styled (c, true, " -- ", stream);
1799 print_doc_line (stream, c.doc, false);
1800 gdb_puts ("\n", stream);
1801 if (!c.default_args.empty ())
1802 fput_alias_definition_styled (c, stream);
1804
1805 if (recurse
1806 && c.is_prefix ()
1807 && c.abbrev_flag == 0)
1808 /* Subcommands of a prefix command typically have 'all_commands'
1809 as class. If we pass CLASS to recursive invocation,
1810 most often we won't see anything. */
1811 help_cmd_list (*c.subcommands, all_commands, true, stream);
1812}
1813
1814/*
1815 * Implement a help command on command list LIST.
1816 * RECURSE should be non-zero if this should be done recursively on
1817 * all sublists of LIST.
1818 * STREAM is the stream upon which the output should be written.
1819 * THECLASS should be:
1820 * A non-negative class number to list only commands in that
1821 * ALL_COMMANDS to list all commands in list.
1822 * ALL_CLASSES to list all classes in list.
1823 *
1824 * Note that aliases are only shown when THECLASS is class_alias.
1825 * In the other cases, the aliases will be shown together with their
1826 * aliased command.
1827 *
1828 * Note that RECURSE will be active on *all* sublists, not just the
1829 * ones selected by the criteria above (ie. the selection mechanism
1830 * is at the low level, not the high-level).
1831 */
1832
1833static void
1835 bool recurse, struct ui_file *stream)
1836{
1837 struct cmd_list_element *c;
1838
1839 for (c = list; c; c = c->next)
1840 {
1841 if (c->abbrev_flag == 1 || c->cmd_deprecated)
1842 {
1843 /* Do not show abbreviations or deprecated commands. */
1844 continue;
1845 }
1846
1847 if (c->is_alias () && theclass != class_alias)
1848 {
1849 /* Do not show an alias, unless specifically showing the
1850 list of aliases: for all other classes, an alias is
1851 shown (if needed) together with its aliased command. */
1852 continue;
1853 }
1854
1855 if (theclass == all_commands
1857 || (theclass == c->theclass && !c->is_command_class_help ()))
1858 {
1859 /* show C when
1860 - showing all commands
1861 - showing all classes and C is a help class
1862 - showing commands of THECLASS and C is not the help class */
1863
1864 /* If we show the class_alias and C is an alias, do not recurse,
1865 as this would show the (possibly very long) not very useful
1866 list of sub-commands of the aliased command. */
1868 (*c,
1869 recurse && (theclass != class_alias || !c->is_alias ()),
1870 stream);
1871 continue;
1872 }
1873
1874 if (recurse
1876 && c->is_prefix ())
1877 {
1878 /* User-defined commands or aliases may be subcommands. */
1879 help_cmd_list (*c->subcommands, theclass, recurse, stream);
1880 continue;
1881 }
1882
1883 /* Do not show C or recurse on C, e.g. because C does not belong to
1884 THECLASS or because C is a help class. */
1885 }
1886}
1887
1888
1889/* Search the input clist for 'command'. Return the command if
1890 found (or NULL if not), and return the number of commands
1891 found in nfound. */
1892
1893static struct cmd_list_element *
1894find_cmd (const char *command, int len, struct cmd_list_element *clist,
1895 int ignore_help_classes, int *nfound)
1896{
1897 struct cmd_list_element *found, *c;
1898
1899 found = NULL;
1900 *nfound = 0;
1901 for (c = clist; c; c = c->next)
1902 if (!strncmp (command, c->name, len)
1903 && (!ignore_help_classes || !c->is_command_class_help ()))
1904 {
1905 found = c;
1906 (*nfound)++;
1907 if (c->name[len] == '\0')
1908 {
1909 *nfound = 1;
1910 break;
1911 }
1912 }
1913 return found;
1914}
1915
1916/* Return the length of command name in TEXT. */
1917
1918int
1920{
1921 const char *p = text;
1922
1923 /* Treating underscores as part of command words is important
1924 so that "set args_foo()" doesn't get interpreted as
1925 "set args _foo()". */
1926 /* Some characters are only used for TUI specific commands.
1927 However, they are always allowed for the sake of consistency.
1928
1929 Note that this is larger than the character set allowed when
1930 creating user-defined commands. */
1931
1932 /* Recognize the single character commands so that, e.g., "!ls"
1933 works as expected. */
1934 if (*p == '!' || *p == '|')
1935 return 1;
1936
1937 while (valid_cmd_char_p (*p)
1938 /* Characters used by TUI specific commands. */
1939 || *p == '+' || *p == '<' || *p == '>' || *p == '$')
1940 p++;
1941
1942 return p - text;
1943}
1944
1945/* See command.h. */
1946
1947bool
1949{
1950 /* Alas "42" is a legitimate user-defined command.
1951 In the interests of not breaking anything we preserve that. */
1952
1953 return isalnum (c) || c == '-' || c == '_' || c == '.';
1954}
1955
1956/* See command.h. */
1957
1958bool
1960{
1961 const char *p;
1962
1963 if (*name == '\0')
1964 return false;
1965
1966 for (p = name; *p != '\0'; ++p)
1967 {
1968 if (valid_cmd_char_p (*p))
1969 ; /* Ok. */
1970 else
1971 return false;
1972 }
1973
1974 return true;
1975}
1976
1977/* See command.h. */
1978
1979struct cmd_list_element *
1980lookup_cmd_1 (const char **text, struct cmd_list_element *clist,
1981 struct cmd_list_element **result_list, std::string *default_args,
1982 int ignore_help_classes, bool lookup_for_completion_p)
1983{
1984 char *command;
1985 int len, nfound;
1986 struct cmd_list_element *found, *c;
1987 bool found_alias = false;
1988 const char *line = *text;
1989
1990 while (**text == ' ' || **text == '\t')
1991 (*text)++;
1992
1993 /* Identify the name of the command. */
1994 len = find_command_name_length (*text);
1995
1996 /* If nothing but whitespace, return 0. */
1997 if (len == 0)
1998 return 0;
1999
2000 /* *text and p now bracket the first command word to lookup (and
2001 it's length is len). We copy this into a local temporary. */
2002
2003
2004 command = (char *) alloca (len + 1);
2005 memcpy (command, *text, len);
2006 command[len] = '\0';
2007
2008 /* Look it up. */
2009 found = 0;
2010 nfound = 0;
2011 found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
2012
2013 /* If nothing matches, we have a simple failure. */
2014 if (nfound == 0)
2015 return 0;
2016
2017 if (nfound > 1)
2018 {
2019 if (result_list != nullptr)
2020 /* Will be modified in calling routine
2021 if we know what the prefix command is. */
2022 *result_list = 0;
2023 if (default_args != nullptr)
2024 *default_args = std::string ();
2025 return CMD_LIST_AMBIGUOUS; /* Ambiguous. */
2026 }
2027
2028 /* We've matched something on this list. Move text pointer forward. */
2029
2030 *text += len;
2031
2032 if (found->is_alias ())
2033 {
2034 /* We drop the alias (abbreviation) in favor of the command it
2035 is pointing to. If the alias is deprecated, though, we need to
2036 warn the user about it before we drop it. Note that while we
2037 are warning about the alias, we may also warn about the command
2038 itself and we will adjust the appropriate DEPRECATED_WARN_USER
2039 flags. */
2040
2041 if (found->deprecated_warn_user && !lookup_for_completion_p)
2042 deprecated_cmd_warning (line, clist);
2043
2044
2045 /* Return the default_args of the alias, not the default_args
2046 of the command it is pointing to. */
2047 if (default_args != nullptr)
2048 *default_args = found->default_args;
2049 found = found->alias_target;
2050 found_alias = true;
2051 }
2052 /* If we found a prefix command, keep looking. */
2053
2054 if (found->is_prefix ())
2055 {
2056 c = lookup_cmd_1 (text, *found->subcommands, result_list, default_args,
2057 ignore_help_classes, lookup_for_completion_p);
2058 if (!c)
2059 {
2060 /* Didn't find anything; this is as far as we got. */
2061 if (result_list != nullptr)
2062 *result_list = clist;
2063 if (!found_alias && default_args != nullptr)
2064 *default_args = found->default_args;
2065 return found;
2066 }
2067 else if (c == CMD_LIST_AMBIGUOUS)
2068 {
2069 /* We've gotten this far properly, but the next step is
2070 ambiguous. We need to set the result list to the best
2071 we've found (if an inferior hasn't already set it). */
2072 if (result_list != nullptr)
2073 if (!*result_list)
2074 /* This used to say *result_list = *found->subcommands.
2075 If that was correct, need to modify the documentation
2076 at the top of this function to clarify what is
2077 supposed to be going on. */
2078 *result_list = found;
2079 /* For ambiguous commands, do not return any default_args args. */
2080 if (default_args != nullptr)
2081 *default_args = std::string ();
2082 return c;
2083 }
2084 else
2085 {
2086 /* We matched! */
2087 return c;
2088 }
2089 }
2090 else
2091 {
2092 if (result_list != nullptr)
2093 *result_list = clist;
2094 if (!found_alias && default_args != nullptr)
2095 *default_args = found->default_args;
2096 return found;
2097 }
2098}
2099
2100/* All this hair to move the space to the front of cmdtype */
2101
2102static void
2103undef_cmd_error (const char *cmdtype, const char *q)
2104{
2105 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
2106 cmdtype,
2107 q,
2108 *cmdtype ? " " : "",
2109 (int) strlen (cmdtype) - 1,
2110 cmdtype);
2111}
2112
2113/* Look up the contents of *LINE as a command in the command list LIST.
2114 LIST is a chain of struct cmd_list_element's.
2115 If it is found, return the struct cmd_list_element for that command,
2116 update *LINE to point after the command name, at the first argument
2117 and update *DEFAULT_ARGS (if DEFAULT_ARGS is not null) to the default
2118 args to prepend to the user provided args when running the command.
2119 Note that if the found cmd_list_element is found via an alias,
2120 the default args of the alias are returned.
2121
2122 If not found, call error if ALLOW_UNKNOWN is zero
2123 otherwise (or if error returns) return zero.
2124 Call error if specified command is ambiguous,
2125 unless ALLOW_UNKNOWN is negative.
2126 CMDTYPE precedes the word "command" in the error message.
2127
2128 If IGNORE_HELP_CLASSES is nonzero, ignore any command list
2129 elements which are actually help classes rather than commands (i.e.
2130 the function field of the struct cmd_list_element is 0). */
2131
2132struct cmd_list_element *
2133lookup_cmd (const char **line, struct cmd_list_element *list,
2134 const char *cmdtype,
2135 std::string *default_args,
2136 int allow_unknown, int ignore_help_classes)
2137{
2138 struct cmd_list_element *last_list = 0;
2139 struct cmd_list_element *c;
2140
2141 /* Note: Do not remove trailing whitespace here because this
2142 would be wrong for complete_command. Jim Kingdon */
2143
2144 if (!*line)
2145 error (_("Lack of needed %scommand"), cmdtype);
2146
2147 c = lookup_cmd_1 (line, list, &last_list, default_args, ignore_help_classes);
2148
2149 if (!c)
2150 {
2151 if (!allow_unknown)
2152 {
2153 char *q;
2154 int len = find_command_name_length (*line);
2155
2156 q = (char *) alloca (len + 1);
2157 strncpy (q, *line, len);
2158 q[len] = '\0';
2159 undef_cmd_error (cmdtype, q);
2160 }
2161 else
2162 return 0;
2163 }
2164 else if (c == CMD_LIST_AMBIGUOUS)
2165 {
2166 /* Ambigous. Local values should be off subcommands or called
2167 values. */
2168 int local_allow_unknown = (last_list ? last_list->allow_unknown :
2170 std::string local_cmdtype
2171 = last_list ? last_list->prefixname () : cmdtype;
2172 struct cmd_list_element *local_list =
2173 (last_list ? *(last_list->subcommands) : list);
2174
2175 if (local_allow_unknown < 0)
2176 {
2177 if (last_list)
2178 return last_list; /* Found something. */
2179 else
2180 return 0; /* Found nothing. */
2181 }
2182 else
2183 {
2184 /* Report as error. */
2185 int amb_len;
2186 char ambbuf[100];
2187
2188 for (amb_len = 0;
2189 ((*line)[amb_len] && (*line)[amb_len] != ' '
2190 && (*line)[amb_len] != '\t');
2191 amb_len++)
2192 ;
2193
2194 ambbuf[0] = 0;
2195 for (c = local_list; c; c = c->next)
2196 if (!strncmp (*line, c->name, amb_len))
2197 {
2198 if (strlen (ambbuf) + strlen (c->name) + 6
2199 < (int) sizeof ambbuf)
2200 {
2201 if (strlen (ambbuf))
2202 strcat (ambbuf, ", ");
2203 strcat (ambbuf, c->name);
2204 }
2205 else
2206 {
2207 strcat (ambbuf, "..");
2208 break;
2209 }
2210 }
2211 error (_("Ambiguous %scommand \"%s\": %s."),
2212 local_cmdtype.c_str (), *line, ambbuf);
2213 }
2214 }
2215 else
2216 {
2217 if (c->type == set_cmd && **line != '\0' && !isspace (**line))
2218 error (_("Argument must be preceded by space."));
2219
2220 /* We've got something. It may still not be what the caller
2221 wants (if this command *needs* a subcommand). */
2222 while (**line == ' ' || **line == '\t')
2223 (*line)++;
2224
2225 if (c->is_prefix () && **line && !c->allow_unknown)
2226 undef_cmd_error (c->prefixname ().c_str (), *line);
2227
2228 /* Seems to be what he wants. Return it. */
2229 return c;
2230 }
2231 return 0;
2232}
2233
2234/* See command.h. */
2235
2236struct cmd_list_element *
2238 struct cmd_list_element *list,
2239 bool ignore_help_classes)
2240{
2241 const char *tem = name;
2242 struct cmd_list_element *cmd = lookup_cmd (&tem, list, "", NULL, -1,
2243 ignore_help_classes);
2244 if (cmd != nullptr && strcmp (name, cmd->name) != 0)
2245 cmd = nullptr;
2246 return cmd;
2247}
2248
2249/* We are here presumably because an alias or command in TEXT is
2250 deprecated and a warning message should be generated. This
2251 function decodes TEXT and potentially generates a warning message
2252 as outlined below.
2253
2254 Example for 'set endian big' which has a fictitious alias 'seb'.
2255
2256 If alias wasn't used in TEXT, and the command is deprecated:
2257 "warning: 'set endian big' is deprecated."
2258
2259 If alias was used, and only the alias is deprecated:
2260 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
2261
2262 If alias was used and command is deprecated (regardless of whether
2263 the alias itself is deprecated:
2264
2265 "warning: 'set endian big' (seb) is deprecated."
2266
2267 After the message has been sent, clear the appropriate flags in the
2268 command and/or the alias so the user is no longer bothered.
2269
2270*/
2271void
2272deprecated_cmd_warning (const char *text, struct cmd_list_element *list)
2273{
2274 struct cmd_list_element *alias = nullptr;
2275 struct cmd_list_element *cmd = nullptr;
2276
2277 /* Return if text doesn't evaluate to a command. We place this lookup
2278 within its own scope so that the PREFIX_CMD local is not visible
2279 later in this function. The value returned in PREFIX_CMD is based on
2280 the prefix found in TEXT, and is our case this prefix can be missing
2281 in some situations (when LIST is not the global CMDLIST).
2282
2283 It is better for our purposes to use the prefix commands directly from
2284 the ALIAS and CMD results. */
2285 {
2286 struct cmd_list_element *prefix_cmd = nullptr;
2287 if (!lookup_cmd_composition_1 (text, &alias, &prefix_cmd, &cmd, list))
2288 return;
2289 }
2290
2291 /* Return if nothing is deprecated. */
2292 if (!((alias != nullptr ? alias->deprecated_warn_user : 0)
2293 || cmd->deprecated_warn_user))
2294 return;
2295
2296 /* Join command prefix (if any) and the command name. */
2297 std::string tmp_cmd_str;
2298 if (cmd->prefix != nullptr)
2299 tmp_cmd_str += cmd->prefix->prefixname ();
2300 tmp_cmd_str += std::string (cmd->name);
2301
2302 /* Display the appropriate first line, this warns that the thing the user
2303 entered is deprecated. */
2304 if (alias != nullptr)
2305 {
2306 /* Join the alias prefix (if any) and the alias name. */
2307 std::string tmp_alias_str;
2308 if (alias->prefix != nullptr)
2309 tmp_alias_str += alias->prefix->prefixname ();
2310 tmp_alias_str += std::string (alias->name);
2311
2312 if (cmd->cmd_deprecated)
2313 gdb_printf (_("Warning: command '%ps' (%ps) is deprecated.\n"),
2315 tmp_cmd_str.c_str ()),
2317 tmp_alias_str.c_str ()));
2318 else
2319 gdb_printf (_("Warning: '%ps', an alias for the command '%ps', "
2320 "is deprecated.\n"),
2322 tmp_alias_str.c_str ()),
2324 tmp_cmd_str.c_str ()));
2325 }
2326 else
2327 gdb_printf (_("Warning: command '%ps' is deprecated.\n"),
2329 tmp_cmd_str.c_str ()));
2330
2331 /* Now display a second line indicating what the user should use instead.
2332 If it is only the alias that is deprecated, we want to indicate the
2333 new alias, otherwise we'll indicate the new command. */
2334 const char *replacement;
2335 if (alias != nullptr && !cmd->cmd_deprecated)
2336 replacement = alias->replacement;
2337 else
2338 replacement = cmd->replacement;
2339 if (replacement != nullptr)
2340 gdb_printf (_("Use '%ps'.\n\n"),
2342 replacement));
2343 else
2344 gdb_printf (_("No alternative known.\n\n"));
2345
2346 /* We've warned you, now we'll keep quiet. */
2347 if (alias != nullptr)
2348 alias->deprecated_warn_user = 0;
2349 cmd->deprecated_warn_user = 0;
2350}
2351
2352/* Look up the contents of TEXT as a command in the command list CUR_LIST.
2353 Return 1 on success, 0 on failure.
2354
2355 If TEXT refers to an alias, *ALIAS will point to that alias.
2356
2357 If TEXT is a subcommand (i.e. one that is preceded by a prefix
2358 command) set *PREFIX_CMD.
2359
2360 Set *CMD to point to the command TEXT indicates.
2361
2362 If any of *ALIAS, *PREFIX_CMD, or *CMD cannot be determined or do not
2363 exist, they are NULL when we return.
2364
2365*/
2366
2367static int
2369 struct cmd_list_element **alias,
2370 struct cmd_list_element **prefix_cmd,
2371 struct cmd_list_element **cmd,
2372 struct cmd_list_element *cur_list)
2373{
2374 *alias = nullptr;
2375 *prefix_cmd = cur_list->prefix;
2376 *cmd = nullptr;
2377
2378 text = skip_spaces (text);
2379
2380 /* Go through as many command lists as we need to, to find the command
2381 TEXT refers to. */
2382 while (1)
2383 {
2384 /* Identify the name of the command. */
2385 int len = find_command_name_length (text);
2386
2387 /* If nothing but whitespace, return. */
2388 if (len == 0)
2389 return 0;
2390
2391 /* TEXT is the start of the first command word to lookup (and
2392 it's length is LEN). We copy this into a local temporary. */
2393 std::string command (text, len);
2394
2395 /* Look it up. */
2396 int nfound = 0;
2397 *cmd = find_cmd (command.c_str (), len, cur_list, 1, &nfound);
2398
2399 /* We only handle the case where a single command was found. */
2400 if (*cmd == CMD_LIST_AMBIGUOUS || *cmd == nullptr)
2401 return 0;
2402 else
2403 {
2404 if ((*cmd)->is_alias ())
2405 {
2406 /* If the command was actually an alias, we note that an
2407 alias was used (by assigning *ALIAS) and we set *CMD. */
2408 *alias = *cmd;
2409 *cmd = (*cmd)->alias_target;
2410 }
2411 }
2412
2413 text += len;
2414 text = skip_spaces (text);
2415
2416 if ((*cmd)->is_prefix () && *text != '\0')
2417 {
2418 cur_list = *(*cmd)->subcommands;
2419 *prefix_cmd = *cmd;
2420 }
2421 else
2422 return 1;
2423 }
2424}
2425
2426/* Look up the contents of TEXT as a command in the command list 'cmdlist'.
2427 Return 1 on success, 0 on failure.
2428
2429 If TEXT refers to an alias, *ALIAS will point to that alias.
2430
2431 If TEXT is a subcommand (i.e. one that is preceded by a prefix
2432 command) set *PREFIX_CMD.
2433
2434 Set *CMD to point to the command TEXT indicates.
2435
2436 If any of *ALIAS, *PREFIX_CMD, or *CMD cannot be determined or do not
2437 exist, they are NULL when we return.
2438
2439*/
2440
2441int
2442lookup_cmd_composition (const char *text,
2443 struct cmd_list_element **alias,
2444 struct cmd_list_element **prefix_cmd,
2445 struct cmd_list_element **cmd)
2446{
2447 return lookup_cmd_composition_1 (text, alias, prefix_cmd, cmd, cmdlist);
2448}
2449
2450/* Helper function for SYMBOL_COMPLETION_FUNCTION. */
2451
2452/* Return a vector of char pointers which point to the different
2453 possible completions in LIST of TEXT.
2454
2455 WORD points in the same buffer as TEXT, and completions should be
2456 returned relative to this position. For example, suppose TEXT is
2457 "foo" and we want to complete to "foobar". If WORD is "oo", return
2458 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
2459
2460void
2462 completion_tracker &tracker,
2463 const char *text, const char *word,
2464 int ignore_help_classes)
2465{
2466 struct cmd_list_element *ptr;
2467 int textlen = strlen (text);
2468 int pass;
2469 int saw_deprecated_match = 0;
2470
2471 /* We do one or two passes. In the first pass, we skip deprecated
2472 commands. If we see no matching commands in the first pass, and
2473 if we did happen to see a matching deprecated command, we do
2474 another loop to collect those. */
2475 for (pass = 0; pass < 2; ++pass)
2476 {
2477 bool got_matches = false;
2478
2479 for (ptr = list; ptr; ptr = ptr->next)
2480 if (!strncmp (ptr->name, text, textlen)
2481 && !ptr->abbrev_flag
2482 && (!ignore_help_classes || !ptr->is_command_class_help ()
2483 || ptr->is_prefix ()))
2484 {
2485 if (pass == 0)
2486 {
2487 if (ptr->cmd_deprecated)
2488 {
2489 saw_deprecated_match = 1;
2490 continue;
2491 }
2492 }
2493
2494 tracker.add_completion
2495 (make_completion_match_str (ptr->name, text, word));
2496 got_matches = true;
2497 }
2498
2499 if (got_matches)
2500 break;
2501
2502 /* If we saw no matching deprecated commands in the first pass,
2503 just bail out. */
2504 if (!saw_deprecated_match)
2505 break;
2506 }
2507}
2508
2509/* Helper function for SYMBOL_COMPLETION_FUNCTION. */
2510
2511/* Add the different possible completions in ENUMLIST of TEXT.
2512
2513 WORD points in the same buffer as TEXT, and completions should be
2514 returned relative to this position. For example, suppose TEXT is "foo"
2515 and we want to complete to "foobar". If WORD is "oo", return
2516 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
2517
2518void
2520 const char *const *enumlist,
2521 const char *text, const char *word)
2522{
2523 int textlen = strlen (text);
2524 int i;
2525 const char *name;
2526
2527 for (i = 0; (name = enumlist[i]) != NULL; i++)
2528 if (strncmp (name, text, textlen) == 0)
2529 tracker.add_completion (make_completion_match_str (name, text, word));
2530}
2531
2532/* Call the command function. */
2533void
2534cmd_func (struct cmd_list_element *cmd, const char *args, int from_tty)
2535{
2536 if (!cmd->is_command_class_help ())
2537 {
2538 gdb::optional<scoped_restore_tmpl<bool>> restore_suppress;
2539
2540 if (cmd->suppress_notification != NULL)
2541 restore_suppress.emplace (cmd->suppress_notification, true);
2542
2543 cmd->func (args, from_tty, cmd);
2544 }
2545 else
2546 error (_("Invalid command"));
2547}
2548
2549int
2551{
2552 return cmd->theclass == class_user && cmd->func == do_simple_func;
2553}
const char *const name
Definition: aarch64-tdep.c:67
void * xmalloc(YYSIZE_T)
void xfree(void *)
ui_file_style style() const
Definition: cli-style.c:169
void add_completion(gdb::unique_xmalloc_ptr< char > name, completion_match_for_lcd *match_for_lcd=NULL, const char *text=NULL, const char *word=NULL)
Definition: completer.c:1579
virtual void wrap_here(int indent)
Definition: ui-file.h:117
struct cmd_list_element * infolist
Definition: cli-cmds.c:89
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:85
struct cmd_list_element * add_cmd_suppress_notification(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, struct cmd_list_element **list, bool *suppress_notification)
Definition: cli-decode.c:255
static void empty_func(const char *args, int from_tty, cmd_list_element *c)
Definition: cli-decode.c:490
set_show_commands add_setshow_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:785
static void fput_aliases_definition_styled(const cmd_list_element &cmd, struct ui_file *stream)
Definition: cli-decode.c:1383
static int lookup_cmd_composition_1(const char *text, struct cmd_list_element **alias, struct cmd_list_element **prefix_cmd, struct cmd_list_element **cmd, struct cmd_list_element *cur_list)
Definition: cli-decode.c:2368
set_show_commands add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:1053
static void help_all(struct ui_file *stream)
Definition: cli-decode.c:1708
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *target, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:294
struct cmd_list_element * lookup_cmd(const char **line, struct cmd_list_element *list, const char *cmdtype, std::string *default_args, int allow_unknown, int ignore_help_classes)
Definition: cli-decode.c:2133
set_show_commands add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:1103
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:233
void set_cmd_completer_handle_brkchars(struct cmd_list_element *cmd, completer_handle_brkchars_ftype *func)
Definition: cli-decode.c:125
void help_cmd(const char *command, struct ui_file *stream)
Definition: cli-decode.c:1552
void complete_on_cmdlist(struct cmd_list_element *list, completion_tracker &tracker, const char *text, const char *word, int ignore_help_classes)
Definition: cli-decode.c:2461
struct cmd_list_element * add_com_suppress_notification(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, bool *suppress_notification)
Definition: cli-decode.c:1332
struct cmd_list_element * add_abbrev_prefix_cmd(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:468
void deprecated_cmd_warning(const char *text, struct cmd_list_element *list)
Definition: cli-decode.c:2272
bool valid_cmd_char_p(int c)
Definition: cli-decode.c:1948
static void help_cmd_list(struct cmd_list_element *list, enum command_class theclass, bool recurse, struct ui_file *stream)
Definition: cli-decode.c:1834
static struct cmd_list_element * add_set_or_show_cmd(const char *name, enum cmd_types type, enum command_class theclass, var_types var_type, const setting::erased_args &arg, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:507
static void print_help_for_command(const cmd_list_element &c, bool recurse, struct ui_file *stream)
Definition: cli-decode.c:1795
cmd_list_element * add_com_alias(const char *name, cmd_list_element *target, command_class theclass, int abbrev_flag)
Definition: cli-decode.c:1323
set_show_commands add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:934
struct cmd_list_element * lookup_cmd_1(const char **text, struct cmd_list_element *clist, struct cmd_list_element **result_list, std::string *default_args, int ignore_help_classes, bool lookup_for_completion_p)
Definition: cli-decode.c:1980
static void set_cmd_simple_func(struct cmd_list_element *cmd, cmd_simple_func_ftype *simple_func)
Definition: cli-decode.c:99
static void update_prefix_field_of_prefixed_commands(struct cmd_list_element *c)
Definition: cli-decode.c:328
set_show_commands add_setshow_string_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:833
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1649
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:117
static set_show_commands add_setshow_cmd_full(const char *name, enum command_class theclass, var_types var_type, T *var, const char *set_doc, const char *show_doc, const char *help_doc, typename setting_func_types< T >::set set_setting_func, typename setting_func_types< T >::get get_setting_func, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:585
static void print_doc_of_command(const cmd_list_element &c, const char *prefix, bool verbose, compiled_regex &highlight, struct ui_file *stream)
Definition: cli-decode.c:1446
static void fput_alias_definition_styled(const cmd_list_element &c, struct ui_file *stream)
Definition: cli-decode.c:1368
struct cmd_list_element * add_show_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:414
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
Definition: cli-decode.c:1310
set_show_commands add_setshow_zuinteger_unlimited_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:1138
static bool user_documented_alias(const cmd_list_element &alias)
Definition: cli-decode.c:1355
void apropos_cmd(struct ui_file *stream, struct cmd_list_element *commandlist, bool verbose, compiled_regex &regex, const char *prefix)
Definition: cli-decode.c:1481
static void do_prefix_cmd(const char *args, int from_tty, struct cmd_list_element *c)
Definition: cli-decode.c:378
set_show_commands add_setshow_integer_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:1004
void cmd_func(struct cmd_list_element *cmd, const char *args, int from_tty)
Definition: cli-decode.c:2534
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:618
void not_just_help_class_command(const char *args, int from_tty)
Definition: cli-decode.c:483
static void integer_unlimited_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: cli-decode.c:982
static void do_simple_func(const char *args, int from_tty, cmd_list_element *c)
Definition: cli-decode.c:93
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
Definition: cli-decode.c:280
struct cmd_list_element * add_prefix_cmd_suppress_notification(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list, bool *suppress_notification)
Definition: cli-decode.c:452
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
Definition: cli-decode.c:428
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:357
static cmd_list_element::aliases_list_type delete_cmd(const char *name, cmd_list_element **list, cmd_list_element **prehook, cmd_list_element **prehookee, cmd_list_element **posthook, cmd_list_element **posthookee)
Definition: cli-decode.c:1232
bool valid_user_defined_cmd_name_p(const char *name)
Definition: cli-decode.c:1959
static void fput_command_name_styled(const cmd_list_element &c, struct ui_file *stream)
Definition: cli-decode.c:1343
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:739
int find_command_name_length(const char *text)
Definition: cli-decode.c:1919
cmd_list_element * add_info_alias(const char *name, cmd_list_element *target, int abbrev_flag)
Definition: cli-decode.c:1302
int cmd_simple_func_eq(struct cmd_list_element *cmd, cmd_simple_func_ftype *simple_func)
Definition: cli-decode.c:110
const char *const boolean_enums[]
Definition: cli-decode.c:730
static struct cmd_list_element * lookup_cmd_with_subcommands(cmd_list_element **subcommands, cmd_list_element *list)
Definition: cli-decode.c:61
static void fput_command_names_styled(const cmd_list_element &c, bool always_fput_c_name, const char *postfix, struct ui_file *stream)
Definition: cli-decode.c:1400
set_show_commands add_setshow_string_noescape_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:883
static struct cmd_list_element * find_cmd(const char *command, int len, struct cmd_list_element *clist, int ignore_help_classes, int *nfound)
Definition: cli-decode.c:1894
set_show_commands add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:682
int lookup_cmd_composition(const char *text, struct cmd_list_element **alias, struct cmd_list_element **prefix_cmd, struct cmd_list_element **cmd)
Definition: cli-decode.c:2442
static void do_show_prefix_cmd(const char *args, int from_tty, struct cmd_list_element *c)
Definition: cli-decode.c:406
struct cmd_list_element * lookup_cmd_exact(const char *name, struct cmd_list_element *list, bool ignore_help_classes)
Definition: cli-decode.c:2237
void complete_on_enum(completion_tracker &tracker, const char *const *enumlist, const char *text, const char *word)
Definition: cli-decode.c:2519
struct cmd_list_element * add_basic_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:391
int cli_user_command_p(struct cmd_list_element *cmd)
Definition: cli-decode.c:2550
const char *const auto_boolean_enums[]
Definition: cli-decode.c:674
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
Definition: cli-decode.c:1294
static void undef_cmd_error(const char *, const char *)
Definition: cli-decode.c:2103
static struct cmd_list_element * do_add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:181
void print_doc_line(struct ui_file *stream, const char *str, bool for_value_prefix)
Definition: cli-decode.c:1752
static set_show_commands add_setshow_cmd_full_erased(const char *name, enum command_class theclass, var_types var_type, const setting::erased_args &args, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:539
set_show_commands add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:1190
cmd_types
Definition: cli-decode.h:36
@ set_cmd
Definition: cli-decode.h:38
@ show_cmd
Definition: cli-decode.h:39
void cmd_show_list(struct cmd_list_element *list, int from_tty)
Definition: cli-setshow.c:700
cli_style_option title_style
#define CMD_LIST_AMBIGUOUS
Definition: command.h:523
void completer_ftype(struct cmd_list_element *, completion_tracker &tracker, const char *text, const char *word)
Definition: command.h:495
void cmd_simple_func_ftype(const char *args, int from_tty)
Definition: command.h:372
void() show_value_ftype(struct ui_file *file, int from_tty, struct cmd_list_element *cmd, const char *value)
Definition: command.h:646
var_types
Definition: command.h:75
@ var_optional_filename
Definition: command.h:106
@ var_integer
Definition: command.h:95
@ var_string
Definition: command.h:100
@ var_boolean
Definition: command.h:78
@ var_auto_boolean
Definition: command.h:85
@ var_zuinteger_unlimited
Definition: command.h:118
@ var_string_noescape
Definition: command.h:103
@ var_zuinteger
Definition: command.h:114
@ var_filename
Definition: command.h:108
@ var_zinteger
Definition: command.h:111
@ var_uinteger
Definition: command.h:89
@ var_enum
Definition: command.h:122
void completer_handle_brkchars_ftype(struct cmd_list_element *, completion_tracker &tracker, const char *text, const char *word)
Definition: command.h:500
void cmd_func_ftype(const char *args, int from_tty, cmd_list_element *c)
Definition: command.h:483
command_class
Definition: command.h:43
@ class_user
Definition: command.h:67
@ all_commands
Definition: command.h:50
@ class_alias
Definition: command.h:62
@ class_run
Definition: command.h:54
@ all_classes
Definition: command.h:49
@ no_class
Definition: command.h:53
@ class_info
Definition: command.h:59
gdb::unique_xmalloc_ptr< char > make_completion_match_str(const char *match_name, const char *text, const char *word)
Definition: completer.c:1646
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:204
auto_boolean
Definition: defs.h:248
const char * alias
Definition: nds32-tdep.c:114
#define prefix(a, b, R, do)
Definition: ppc64-tdep.c:52
void(* func)(remote_target *remote, char *)
Definition: 1.cc:26
unsigned int doc_allocated
Definition: cli-decode.h:145
struct cmd_list_element * hook_post
Definition: cli-decode.h:206
unsigned int abbrev_flag
Definition: cli-decode.h:164
aliases_list_type aliases
Definition: cli-decode.h:268
struct cmd_list_element * hookee_post
Definition: cli-decode.h:251
const char * doc
Definition: cli-decode.h:193
std::vector< std::string > command_components() const
Definition: cli-decode.c:151
bool * suppress_notification
Definition: cli-decode.h:274
cmd_simple_func_ftype * simple_func
Definition: cli-decode.h:185
cmd_func_ftype * func
Definition: cli-decode.h:175
gdb::optional< setting > var
Definition: cli-decode.h:236
struct cmd_list_element * hookee_pre
Definition: cli-decode.h:247
struct cmd_list_element * hook_pre
Definition: cli-decode.h:203
std::string prefixname() const
Definition: cli-decode.c:132
std::string default_args
Definition: cli-decode.h:210
struct cmd_list_element ** subcommands
Definition: cli-decode.h:214
completer_handle_brkchars_ftype * completer_handle_brkchars
Definition: cli-decode.h:228
unsigned int cmd_deprecated
Definition: cli-decode.h:124
completer_ftype * completer
Definition: cli-decode.h:220
struct cmd_list_element * prefix
Definition: cli-decode.h:217
unsigned int deprecated_warn_user
Definition: cli-decode.h:130
bool is_alias() const
Definition: cli-decode.h:90
bool is_command_class_help() const
Definition: cli-decode.h:100
intrusive_list< cmd_list_element, aliases_list_member_node_type > aliases_list_type
Definition: cli-decode.h:267
void * context() const
Definition: cli-decode.h:109
__extension__ enum cmd_types type
Definition: cli-decode.h:168
void(* destroyer)(struct cmd_list_element *self, void *context)
Definition: cli-decode.h:233
struct cmd_list_element * next
Definition: cli-decode.h:113
struct cmd_list_element * alias_target
Definition: cli-decode.h:255
const char * name
Definition: cli-decode.h:116
const char *const * enums
Definition: cli-decode.h:240
bool is_prefix() const
Definition: cli-decode.h:94
show_value_ftype * show_value_func
Definition: cli-decode.h:197
const char * replacement
Definition: cli-decode.h:200
unsigned int allow_unknown
Definition: cli-decode.h:158
enum command_class theclass
Definition: cli-decode.h:119
union cmd_list_element::@25 function
cmd_list_element * set
Definition: command.h:406
cmd_list_element * show
Definition: command.h:406
typename setting_func_types_1< std::is_scalar< T >::value, T >::get get
Definition: command.h:205
typename setting_func_types_1< std::is_scalar< T >::value, T >::set set
Definition: command.h:204
static erased_args erase_args(var_types var_type, T *var, typename setting_func_types< T >::set set_setting_func, typename setting_func_types< T >::get get_setting_func)
Definition: command.h:240
Definition: gdbtypes.h:922
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition: ui-out.h:151
void fputs_highlighted(const char *str, const compiled_regex &highlight, struct ui_file *stream)
Definition: utils.c:1807
void fprintf_styled(struct ui_file *stream, const ui_file_style &style, const char *format,...)
Definition: utils.c:1877
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition: utils.c:1865
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1788
#define gdb_stdout
Definition: utils.h:188