1 /* Handle lists of commands, their decoding and documentation, for GDB.
3 Copyright (c) 1986, 1989-1991, 1998, 2000-2002, 2004, 2007-2012 Free
4 Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_regex.h"
23 #include "gdb_string.h"
24 #include "completer.h"
27 #include "cli/cli-cmds.h"
28 #include "cli/cli-decode.h"
31 #include "tui/tui.h" /* For tui_active et al. */
34 #include "gdb_assert.h"
36 /* Prototypes for local functions. */
38 static void undef_cmd_error (char *, char *);
40 static struct cmd_list_element
*delete_cmd (char *name
,
41 struct cmd_list_element
**list
,
42 struct cmd_list_element
**prehook
,
43 struct cmd_list_element
**prehookee
,
44 struct cmd_list_element
**posthook
,
45 struct cmd_list_element
**posthookee
);
47 static struct cmd_list_element
*find_cmd (char *command
,
49 struct cmd_list_element
*clist
,
50 int ignore_help_classes
,
53 static void help_all (struct ui_file
*stream
);
55 /* Look up a command whose 'prefixlist' is KEY. Return the command if found,
56 otherwise return NULL. */
58 static struct cmd_list_element
*
59 lookup_cmd_for_prefixlist (struct cmd_list_element
**key
,
60 struct cmd_list_element
*list
)
62 struct cmd_list_element
*p
= NULL
;
64 for (p
= list
; p
!= NULL
; p
= p
->next
)
66 struct cmd_list_element
*q
;
68 if (p
->prefixlist
== NULL
)
70 else if (p
->prefixlist
== key
)
73 q
= lookup_cmd_for_prefixlist (key
, *(p
->prefixlist
));
82 set_cmd_prefix (struct cmd_list_element
*c
, struct cmd_list_element
**list
)
84 struct cmd_list_element
*p
;
86 /* Check to see if *LIST contains any element other than C. */
87 for (p
= *list
; p
!= NULL
; p
= p
->next
)
93 /* *SET_LIST only contains SET. */
94 p
= lookup_cmd_for_prefixlist (list
, setlist
);
96 c
->prefix
= p
? (p
->cmd_pointer
? p
->cmd_pointer
: p
) : p
;
99 c
->prefix
= p
->prefix
;
103 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
104 struct ui_file
*stream
);
107 /* Set the callback function for the specified command. For each both
108 the commands callback and func() are set. The latter set to a
109 bounce function (unless cfunc / sfunc is NULL that is). */
112 do_cfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
114 c
->function
.cfunc (args
, from_tty
); /* Ok. */
118 set_cmd_cfunc (struct cmd_list_element
*cmd
, cmd_cfunc_ftype
*cfunc
)
123 cmd
->func
= do_cfunc
;
124 cmd
->function
.cfunc
= cfunc
; /* Ok. */
128 do_sfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
130 c
->function
.sfunc (args
, from_tty
, c
); /* Ok. */
134 set_cmd_sfunc (struct cmd_list_element
*cmd
, cmd_sfunc_ftype
*sfunc
)
139 cmd
->func
= do_sfunc
;
140 cmd
->function
.sfunc
= sfunc
; /* Ok. */
144 cmd_cfunc_eq (struct cmd_list_element
*cmd
,
145 void (*cfunc
) (char *args
, int from_tty
))
147 return cmd
->func
== do_cfunc
&& cmd
->function
.cfunc
== cfunc
;
151 set_cmd_context (struct cmd_list_element
*cmd
, void *context
)
153 cmd
->context
= context
;
157 get_cmd_context (struct cmd_list_element
*cmd
)
163 cmd_type (struct cmd_list_element
*cmd
)
169 set_cmd_completer (struct cmd_list_element
*cmd
, completer_ftype
*completer
)
171 cmd
->completer
= completer
; /* Ok. */
174 /* Add element named NAME.
175 Space for NAME and DOC must be allocated by the caller.
176 CLASS is the top level category into which commands are broken down
178 FUN should be the function to execute the command;
179 it will get a character string as argument, with leading
180 and trailing blanks already eliminated.
182 DOC is a documentation string for the command.
183 Its first line should be a complete sentence.
184 It should start with ? for a command that is an abbreviation
185 or with * for a command that most users don't need to know about.
187 Add this command to command list *LIST.
189 Returns a pointer to the added command (not necessarily the head
192 struct cmd_list_element
*
193 add_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
194 char *doc
, struct cmd_list_element
**list
)
196 struct cmd_list_element
*c
197 = (struct cmd_list_element
*) xmalloc (sizeof (struct cmd_list_element
));
198 struct cmd_list_element
*p
, *iter
;
200 /* Turn each alias of the old command into an alias of the new
202 c
->aliases
= delete_cmd (name
, list
, &c
->hook_pre
, &c
->hookee_pre
,
203 &c
->hook_post
, &c
->hookee_post
);
204 for (iter
= c
->aliases
; iter
; iter
= iter
->alias_chain
)
205 iter
->cmd_pointer
= c
;
207 c
->hook_pre
->hookee_pre
= c
;
209 c
->hookee_pre
->hook_pre
= c
;
211 c
->hook_post
->hookee_post
= c
;
213 c
->hookee_post
->hook_post
= c
;
215 if (*list
== NULL
|| strcmp ((*list
)->name
, name
) >= 0)
223 while (p
->next
&& strcmp (p
->next
->name
, name
) <= 0)
233 set_cmd_cfunc (c
, fun
);
234 set_cmd_context (c
, NULL
);
237 c
->replacement
= NULL
;
238 c
->pre_show_hook
= NULL
;
240 c
->prefixlist
= NULL
;
241 c
->prefixname
= NULL
;
242 c
->allow_unknown
= 0;
245 set_cmd_completer (c
, make_symbol_completion_list_fn
);
247 c
->type
= not_set_cmd
;
249 c
->var_type
= var_boolean
;
251 c
->user_commands
= NULL
;
252 c
->cmd_pointer
= NULL
;
253 c
->alias_chain
= NULL
;
258 /* Deprecates a command CMD.
259 REPLACEMENT is the name of the command which should be used in
260 place of this command, or NULL if no such command exists.
262 This function does not check to see if command REPLACEMENT exists
263 since gdb may not have gotten around to adding REPLACEMENT when
264 this function is called.
266 Returns a pointer to the deprecated command. */
268 struct cmd_list_element
*
269 deprecate_cmd (struct cmd_list_element
*cmd
, char *replacement
)
271 cmd
->flags
|= (CMD_DEPRECATED
| DEPRECATED_WARN_USER
);
273 if (replacement
!= NULL
)
274 cmd
->replacement
= replacement
;
276 cmd
->replacement
= NULL
;
281 struct cmd_list_element
*
282 add_alias_cmd (char *name
, char *oldname
, enum command_class
class,
283 int abbrev_flag
, struct cmd_list_element
**list
)
285 /* Must do this since lookup_cmd tries to side-effect its first
288 struct cmd_list_element
*old
;
289 struct cmd_list_element
*c
;
291 copied_name
= (char *) alloca (strlen (oldname
) + 1);
292 strcpy (copied_name
, oldname
);
293 old
= lookup_cmd (&copied_name
, *list
, "", 1, 1);
297 struct cmd_list_element
*prehook
, *prehookee
, *posthook
, *posthookee
;
298 struct cmd_list_element
*aliases
= delete_cmd (name
, list
,
299 &prehook
, &prehookee
,
300 &posthook
, &posthookee
);
302 /* If this happens, it means a programmer error somewhere. */
303 gdb_assert (!aliases
&& !prehook
&& !prehookee
304 && !posthook
&& ! posthookee
);
308 c
= add_cmd (name
, class, NULL
, old
->doc
, list
);
309 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
311 c
->function
= old
->function
;
312 c
->prefixlist
= old
->prefixlist
;
313 c
->prefixname
= old
->prefixname
;
314 c
->allow_unknown
= old
->allow_unknown
;
315 c
->abbrev_flag
= abbrev_flag
;
316 c
->cmd_pointer
= old
;
317 c
->alias_chain
= old
->aliases
;
320 set_cmd_prefix (c
, list
);
324 /* Like add_cmd but adds an element for a command prefix: a name that
325 should be followed by a subcommand to be looked up in another
326 command list. PREFIXLIST should be the address of the variable
327 containing that list. */
329 struct cmd_list_element
*
330 add_prefix_cmd (char *name
, enum command_class
class,
331 void (*fun
) (char *, int),
332 char *doc
, struct cmd_list_element
**prefixlist
,
333 char *prefixname
, int allow_unknown
,
334 struct cmd_list_element
**list
)
336 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
337 struct cmd_list_element
*p
;
339 c
->prefixlist
= prefixlist
;
340 c
->prefixname
= prefixname
;
341 c
->allow_unknown
= allow_unknown
;
343 if (list
== &cmdlist
)
346 set_cmd_prefix (c
, list
);
348 /* Update the field 'prefix' of each cmd_list_element in *PREFIXLIST. */
349 for (p
= *prefixlist
; p
!= NULL
; p
= p
->next
)
355 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
357 struct cmd_list_element
*
358 add_abbrev_prefix_cmd (char *name
, enum command_class
class,
359 void (*fun
) (char *, int), char *doc
,
360 struct cmd_list_element
**prefixlist
, char *prefixname
,
361 int allow_unknown
, struct cmd_list_element
**list
)
363 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
365 c
->prefixlist
= prefixlist
;
366 c
->prefixname
= prefixname
;
367 c
->allow_unknown
= allow_unknown
;
372 /* This is an empty "cfunc". */
374 not_just_help_class_command (char *args
, int from_tty
)
378 /* This is an empty "sfunc". */
379 static void empty_sfunc (char *, int, struct cmd_list_element
*);
382 empty_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
386 /* Add element named NAME to command list LIST (the list for set/show
387 or some sublist thereof).
388 TYPE is set_cmd or show_cmd.
389 CLASS is as in add_cmd.
390 VAR_TYPE is the kind of thing we are setting.
391 VAR is address of the variable being controlled by this command.
392 DOC is the documentation string. */
394 static struct cmd_list_element
*
395 add_set_or_show_cmd (char *name
,
397 enum command_class
class,
401 struct cmd_list_element
**list
)
403 struct cmd_list_element
*c
= add_cmd (name
, class, NULL
, doc
, list
);
405 gdb_assert (type
== set_cmd
|| type
== show_cmd
);
407 c
->var_type
= var_type
;
409 /* This needs to be something besides NULL so that this isn't
410 treated as a help class. */
411 set_cmd_sfunc (c
, empty_sfunc
);
415 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
416 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
417 setting. VAR is address of the variable being controlled by this
418 command. SET_FUNC and SHOW_FUNC are the callback functions (if
419 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
420 strings. PRINT the format string to print the value. SET_RESULT
421 and SHOW_RESULT, if not NULL, are set to the resulting command
425 add_setshow_cmd_full (char *name
,
426 enum command_class
class,
427 var_types var_type
, void *var
,
428 const char *set_doc
, const char *show_doc
,
429 const char *help_doc
,
430 cmd_sfunc_ftype
*set_func
,
431 show_value_ftype
*show_func
,
432 struct cmd_list_element
**set_list
,
433 struct cmd_list_element
**show_list
,
434 struct cmd_list_element
**set_result
,
435 struct cmd_list_element
**show_result
)
437 struct cmd_list_element
*set
;
438 struct cmd_list_element
*show
;
442 if (help_doc
!= NULL
)
444 full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
445 full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
449 full_set_doc
= xstrdup (set_doc
);
450 full_show_doc
= xstrdup (show_doc
);
452 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
453 full_set_doc
, set_list
);
454 if (set_func
!= NULL
)
455 set_cmd_sfunc (set
, set_func
);
457 set_cmd_prefix (set
, set_list
);
459 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
460 full_show_doc
, show_list
);
461 show
->show_value_func
= show_func
;
463 if (set_result
!= NULL
)
465 if (show_result
!= NULL
)
469 /* Add element named NAME to command list LIST (the list for set or
470 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
471 of strings which may follow NAME. VAR is address of the variable
472 which will contain the matching string (from ENUMLIST). */
475 add_setshow_enum_cmd (char *name
,
476 enum command_class
class,
477 const char *const *enumlist
,
480 const char *show_doc
,
481 const char *help_doc
,
482 cmd_sfunc_ftype
*set_func
,
483 show_value_ftype
*show_func
,
484 struct cmd_list_element
**set_list
,
485 struct cmd_list_element
**show_list
)
487 struct cmd_list_element
*c
;
489 add_setshow_cmd_full (name
, class, var_enum
, var
,
490 set_doc
, show_doc
, help_doc
,
497 const char * const auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
499 /* Add an auto-boolean command named NAME to both the set and show
500 command list lists. CLASS is as in add_cmd. VAR is address of the
501 variable which will contain the value. DOC is the documentation
502 string. FUNC is the corresponding callback. */
504 add_setshow_auto_boolean_cmd (char *name
,
505 enum command_class
class,
506 enum auto_boolean
*var
,
507 const char *set_doc
, const char *show_doc
,
508 const char *help_doc
,
509 cmd_sfunc_ftype
*set_func
,
510 show_value_ftype
*show_func
,
511 struct cmd_list_element
**set_list
,
512 struct cmd_list_element
**show_list
)
514 struct cmd_list_element
*c
;
516 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
517 set_doc
, show_doc
, help_doc
,
521 c
->enums
= auto_boolean_enums
;
524 /* Add element named NAME to both the set and show command LISTs (the
525 list for set/show or some sublist thereof). CLASS is as in
526 add_cmd. VAR is address of the variable which will contain the
527 value. SET_DOC and SHOW_DOC are the documentation strings. */
529 add_setshow_boolean_cmd (char *name
, enum command_class
class, int *var
,
530 const char *set_doc
, const char *show_doc
,
531 const char *help_doc
,
532 cmd_sfunc_ftype
*set_func
,
533 show_value_ftype
*show_func
,
534 struct cmd_list_element
**set_list
,
535 struct cmd_list_element
**show_list
)
537 static const char *boolean_enums
[] = { "on", "off", NULL
};
538 struct cmd_list_element
*c
;
540 add_setshow_cmd_full (name
, class, var_boolean
, var
,
541 set_doc
, show_doc
, help_doc
,
545 c
->enums
= boolean_enums
;
548 /* Add element named NAME to both the set and show command LISTs (the
549 list for set/show or some sublist thereof). */
551 add_setshow_filename_cmd (char *name
, enum command_class
class,
553 const char *set_doc
, const char *show_doc
,
554 const char *help_doc
,
555 cmd_sfunc_ftype
*set_func
,
556 show_value_ftype
*show_func
,
557 struct cmd_list_element
**set_list
,
558 struct cmd_list_element
**show_list
)
560 struct cmd_list_element
*set_result
;
562 add_setshow_cmd_full (name
, class, var_filename
, var
,
563 set_doc
, show_doc
, help_doc
,
567 set_cmd_completer (set_result
, filename_completer
);
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_string_cmd (char *name
, enum command_class
class,
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 add_setshow_cmd_full (name
, class, var_string
, var
,
583 set_doc
, show_doc
, help_doc
,
589 /* Add element named NAME to both the set and show command LISTs (the
590 list for set/show or some sublist thereof). */
592 add_setshow_string_noescape_cmd (char *name
, enum command_class
class,
594 const char *set_doc
, const char *show_doc
,
595 const char *help_doc
,
596 cmd_sfunc_ftype
*set_func
,
597 show_value_ftype
*show_func
,
598 struct cmd_list_element
**set_list
,
599 struct cmd_list_element
**show_list
)
601 add_setshow_cmd_full (name
, class, var_string_noescape
, var
,
602 set_doc
, show_doc
, help_doc
,
608 /* Add element named NAME to both the set and show command LISTs (the
609 list for set/show or some sublist thereof). */
611 add_setshow_optional_filename_cmd (char *name
, enum command_class
class,
613 const char *set_doc
, const char *show_doc
,
614 const char *help_doc
,
615 cmd_sfunc_ftype
*set_func
,
616 show_value_ftype
*show_func
,
617 struct cmd_list_element
**set_list
,
618 struct cmd_list_element
**show_list
)
620 struct cmd_list_element
*set_result
;
622 add_setshow_cmd_full (name
, class, var_optional_filename
, var
,
623 set_doc
, show_doc
, help_doc
,
628 set_cmd_completer (set_result
, filename_completer
);
632 /* Add element named NAME to both the set and show command LISTs (the
633 list for set/show or some sublist thereof). CLASS is as in
634 add_cmd. VAR is address of the variable which will contain the
635 value. SET_DOC and SHOW_DOC are the documentation strings. */
637 add_setshow_integer_cmd (char *name
, enum command_class
class,
639 const char *set_doc
, const char *show_doc
,
640 const char *help_doc
,
641 cmd_sfunc_ftype
*set_func
,
642 show_value_ftype
*show_func
,
643 struct cmd_list_element
**set_list
,
644 struct cmd_list_element
**show_list
)
646 add_setshow_cmd_full (name
, class, var_integer
, var
,
647 set_doc
, show_doc
, help_doc
,
653 /* Add element named NAME to both the set and show command LISTs (the
654 list for set/show or some sublist thereof). CLASS is as in
655 add_cmd. VAR is address of the variable which will contain the
656 value. SET_DOC and SHOW_DOC are the documentation strings. */
658 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
660 const char *set_doc
, const char *show_doc
,
661 const char *help_doc
,
662 cmd_sfunc_ftype
*set_func
,
663 show_value_ftype
*show_func
,
664 struct cmd_list_element
**set_list
,
665 struct cmd_list_element
**show_list
)
667 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
668 set_doc
, show_doc
, help_doc
,
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. */
679 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
681 const char *set_doc
, const char *show_doc
,
682 const char *help_doc
,
683 cmd_sfunc_ftype
*set_func
,
684 show_value_ftype
*show_func
,
685 struct cmd_list_element
**set_list
,
686 struct cmd_list_element
**show_list
)
688 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
689 set_doc
, show_doc
, help_doc
,
695 /* Add element named NAME to both the set and show command LISTs (the
696 list for set/show or some sublist thereof). CLASS is as in
697 add_cmd. VAR is address of the variable which will contain the
698 value. SET_DOC and SHOW_DOC are the documentation strings. */
700 add_setshow_zuinteger_cmd (char *name
, enum command_class
class,
702 const char *set_doc
, const char *show_doc
,
703 const char *help_doc
,
704 cmd_sfunc_ftype
*set_func
,
705 show_value_ftype
*show_func
,
706 struct cmd_list_element
**set_list
,
707 struct cmd_list_element
**show_list
)
709 add_setshow_cmd_full (name
, class, var_zuinteger
, var
,
710 set_doc
, show_doc
, help_doc
,
716 /* Remove the command named NAME from the command list. Return the
717 list commands which were aliased to the deleted command. If the
718 command had no aliases, return NULL. The various *HOOKs are set to
719 the pre- and post-hook commands for the deleted command. If the
720 command does not have a hook, the corresponding out parameter is
723 static struct cmd_list_element
*
724 delete_cmd (char *name
, struct cmd_list_element
**list
,
725 struct cmd_list_element
**prehook
,
726 struct cmd_list_element
**prehookee
,
727 struct cmd_list_element
**posthook
,
728 struct cmd_list_element
**posthookee
)
730 struct cmd_list_element
*iter
;
731 struct cmd_list_element
**previous_chain_ptr
;
732 struct cmd_list_element
*aliases
= NULL
;
738 previous_chain_ptr
= list
;
740 for (iter
= *previous_chain_ptr
; iter
; iter
= *previous_chain_ptr
)
742 if (strcmp (iter
->name
, name
) == 0)
745 iter
->destroyer (iter
, iter
->context
);
746 if (iter
->hookee_pre
)
747 iter
->hookee_pre
->hook_pre
= 0;
748 *prehook
= iter
->hook_pre
;
749 *prehookee
= iter
->hookee_pre
;
750 if (iter
->hookee_post
)
751 iter
->hookee_post
->hook_post
= 0;
752 *posthook
= iter
->hook_post
;
753 *posthookee
= iter
->hookee_post
;
755 /* Update the link. */
756 *previous_chain_ptr
= iter
->next
;
758 aliases
= iter
->aliases
;
760 /* If this command was an alias, remove it from the list of
762 if (iter
->cmd_pointer
)
764 struct cmd_list_element
**prevp
= &iter
->cmd_pointer
->aliases
;
765 struct cmd_list_element
*a
= *prevp
;
769 prevp
= &a
->alias_chain
;
772 *prevp
= iter
->alias_chain
;
777 /* We won't see another command with the same name. */
781 previous_chain_ptr
= &iter
->next
;
787 /* Shorthands to the commands above. */
789 /* Add an element to the list of info subcommands. */
791 struct cmd_list_element
*
792 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
794 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
797 /* Add an alias to the list of info subcommands. */
799 struct cmd_list_element
*
800 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
802 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
805 /* Add an element to the list of commands. */
807 struct cmd_list_element
*
808 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
811 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
814 /* Add an alias or abbreviation command to the list of commands. */
816 struct cmd_list_element
*
817 add_com_alias (char *name
, char *oldname
, enum command_class
class,
820 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
823 /* Recursively walk the commandlist structures, and print out the
824 documentation of commands that match our regex in either their
825 name, or their documentation.
828 apropos_cmd (struct ui_file
*stream
,
829 struct cmd_list_element
*commandlist
,
830 struct re_pattern_buffer
*regex
, char *prefix
)
832 struct cmd_list_element
*c
;
835 /* Walk through the commands. */
836 for (c
=commandlist
;c
;c
=c
->next
)
838 returnvalue
= -1; /* Needed to avoid double printing. */
841 /* Try to match against the name. */
842 returnvalue
= re_search (regex
, c
->name
, strlen(c
->name
),
843 0, strlen (c
->name
), NULL
);
844 if (returnvalue
>= 0)
846 print_help_for_command (c
, prefix
,
847 0 /* don't recurse */, stream
);
850 if (c
->doc
!= NULL
&& returnvalue
< 0)
852 /* Try to match against documentation. */
853 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
855 print_help_for_command (c
, prefix
,
856 0 /* don't recurse */, stream
);
859 /* Check if this command has subcommands and is not an
860 abbreviation. We skip listing subcommands of abbreviations
861 in order to avoid duplicates in the output. */
862 if (c
->prefixlist
!= NULL
&& !c
->abbrev_flag
)
864 /* Recursively call ourselves on the subcommand list,
865 passing the right prefix in. */
866 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
871 /* This command really has to deal with two things:
872 1) I want documentation on *this string* (usually called by
875 2) I want documentation on *this list* (usually called by giving a
876 command that requires subcommands. Also called by saying just
879 I am going to split this into two seperate comamnds, help_cmd and
883 help_cmd (char *command
, struct ui_file
*stream
)
885 struct cmd_list_element
*c
;
886 extern struct cmd_list_element
*cmdlist
;
890 help_list (cmdlist
, "", all_classes
, stream
);
894 if (strcmp (command
, "all") == 0)
900 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
905 /* There are three cases here.
906 If c->prefixlist is nonzero, we have a prefix command.
907 Print its documentation, then list its subcommands.
909 If c->func is non NULL, we really have a command. Print its
910 documentation and return.
912 If c->func is NULL, we have a class name. Print its
913 documentation (as if it were a command) and then set class to the
914 number of this class so that the commands in the class will be
917 fputs_filtered (c
->doc
, stream
);
918 fputs_filtered ("\n", stream
);
920 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
922 fprintf_filtered (stream
, "\n");
924 /* If this is a prefix command, print it's subcommands. */
926 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
928 /* If this is a class name, print all of the commands in the class. */
930 help_list (cmdlist
, "", c
->class, stream
);
932 if (c
->hook_pre
|| c
->hook_post
)
933 fprintf_filtered (stream
,
934 "\nThis command has a hook (or hooks) defined:\n");
937 fprintf_filtered (stream
,
938 "\tThis command is run after : %s (pre hook)\n",
941 fprintf_filtered (stream
,
942 "\tThis command is run before : %s (post hook)\n",
947 * Get a specific kind of help on a command list.
950 * CMDTYPE is the prefix to use in the title string.
951 * CLASS is the class with which to list the nodes of this list (see
952 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
953 * everything, ALL_CLASSES for just classes, and non-negative for only things
954 * in a specific class.
955 * and STREAM is the output stream on which to print things.
956 * If you call this routine with a class >= 0, it recurses.
959 help_list (struct cmd_list_element
*list
, char *cmdtype
,
960 enum command_class
class, struct ui_file
*stream
)
963 char *cmdtype1
, *cmdtype2
;
965 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
967 len
= strlen (cmdtype
);
968 cmdtype1
= (char *) alloca (len
+ 1);
970 cmdtype2
= (char *) alloca (len
+ 4);
975 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
977 strncpy (cmdtype2
, cmdtype
, len
- 1);
978 strcpy (cmdtype2
+ len
- 1, " sub");
981 if (class == all_classes
)
982 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
984 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
986 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
988 if (class == all_classes
)
990 fprintf_filtered (stream
, "\n\
991 Type \"help%s\" followed by a class name for a list of commands in ",
994 fprintf_filtered (stream
, "that class.");
996 fprintf_filtered (stream
, "\n\
997 Type \"help all\" for the list of all commands.");
1000 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
1001 cmdtype1
, cmdtype2
);
1003 fputs_filtered ("for ", stream
);
1005 fputs_filtered ("full ", stream
);
1007 fputs_filtered ("documentation.\n", stream
);
1008 fputs_filtered ("Type \"apropos word\" to search "
1009 "for commands related to \"word\".\n", stream
);
1010 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
1015 help_all (struct ui_file
*stream
)
1017 struct cmd_list_element
*c
;
1018 extern struct cmd_list_element
*cmdlist
;
1019 int seen_unclassified
= 0;
1021 for (c
= cmdlist
; c
; c
= c
->next
)
1025 /* If this is a class name, print all of the commands in the
1028 if (c
->func
== NULL
)
1030 fprintf_filtered (stream
, "\nCommand class: %s\n\n", c
->name
);
1031 help_cmd_list (cmdlist
, c
->class, "", 1, stream
);
1035 /* While it's expected that all commands are in some class,
1036 as a safety measure, we'll print commands outside of any
1037 class at the end. */
1039 for (c
= cmdlist
; c
; c
= c
->next
)
1044 if (c
->class == no_class
)
1046 if (!seen_unclassified
)
1048 fprintf_filtered (stream
, "\nUnclassified commands\n\n");
1049 seen_unclassified
= 1;
1051 print_help_for_command (c
, "", 1, stream
);
1057 /* Print only the first line of STR on STREAM. */
1059 print_doc_line (struct ui_file
*stream
, char *str
)
1061 static char *line_buffer
= 0;
1062 static int line_size
;
1068 line_buffer
= (char *) xmalloc (line_size
);
1071 /* Keep printing '.' or ',' not followed by a whitespace for embedded strings
1074 while (*p
&& *p
!= '\n'
1075 && ((*p
!= '.' && *p
!= ',') || (p
[1] && !isspace (p
[1]))))
1077 if (p
- str
> line_size
- 1)
1079 line_size
= p
- str
+ 1;
1080 xfree (line_buffer
);
1081 line_buffer
= (char *) xmalloc (line_size
);
1083 strncpy (line_buffer
, str
, p
- str
);
1084 line_buffer
[p
- str
] = '\0';
1085 if (islower (line_buffer
[0]))
1086 line_buffer
[0] = toupper (line_buffer
[0]);
1087 fputs_filtered (line_buffer
, stream
);
1090 /* Print one-line help for command C.
1091 If RECURSE is non-zero, also print one-line descriptions
1092 of all prefixed subcommands. */
1094 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
1095 struct ui_file
*stream
)
1097 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
1098 print_doc_line (stream
, c
->doc
);
1099 fputs_filtered ("\n", stream
);
1102 && c
->prefixlist
!= 0
1103 && c
->abbrev_flag
== 0)
1104 /* Subcommands of a prefix command typically have 'all_commands'
1105 as class. If we pass CLASS to recursive invocation,
1106 most often we won't see anything. */
1107 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 1, stream
);
1111 * Implement a help command on command list LIST.
1112 * RECURSE should be non-zero if this should be done recursively on
1113 * all sublists of LIST.
1114 * PREFIX is the prefix to print before each command name.
1115 * STREAM is the stream upon which the output should be written.
1117 * A non-negative class number to list only commands in that
1119 * ALL_COMMANDS to list all commands in list.
1120 * ALL_CLASSES to list all classes in list.
1122 * Note that RECURSE will be active on *all* sublists, not just the
1123 * ones selected by the criteria above (ie. the selection mechanism
1124 * is at the low level, not the high-level).
1127 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
1128 char *prefix
, int recurse
, struct ui_file
*stream
)
1130 struct cmd_list_element
*c
;
1132 for (c
= list
; c
; c
= c
->next
)
1134 if (c
->abbrev_flag
== 0
1135 && (class == all_commands
1136 || (class == all_classes
&& c
->func
== NULL
)
1137 || (class == c
->class && c
->func
!= NULL
)))
1139 print_help_for_command (c
, prefix
, recurse
, stream
);
1141 else if (c
->abbrev_flag
== 0 && recurse
1142 && class == class_user
&& c
->prefixlist
!= NULL
)
1143 /* User-defined commands may be subcommands. */
1144 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
,
1150 /* Search the input clist for 'command'. Return the command if
1151 found (or NULL if not), and return the number of commands
1154 static struct cmd_list_element
*
1155 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
1156 int ignore_help_classes
, int *nfound
)
1158 struct cmd_list_element
*found
, *c
;
1160 found
= (struct cmd_list_element
*) NULL
;
1162 for (c
= clist
; c
; c
= c
->next
)
1163 if (!strncmp (command
, c
->name
, len
)
1164 && (!ignore_help_classes
|| c
->func
))
1168 if (c
->name
[len
] == '\0')
1178 find_command_name_length (const char *text
)
1180 const char *p
= text
;
1182 /* Treating underscores as part of command words is important
1183 so that "set args_foo()" doesn't get interpreted as
1184 "set args _foo()". */
1185 /* Some characters are only used for TUI specific commands.
1186 However, they are always allowed for the sake of consistency.
1188 The XDB compatibility characters are only allowed when using the
1189 right mode because they clash with other GDB commands -
1190 specifically '/' is used as a suffix for print, examine and
1193 Note that this is larger than the character set allowed when
1194 creating user-defined commands. */
1196 /* Recognize '!' as a single character command so that, e.g., "!ls"
1197 works as expected. */
1201 while (isalnum (*p
) || *p
== '-' || *p
== '_'
1202 /* Characters used by TUI specific commands. */
1203 || *p
== '+' || *p
== '<' || *p
== '>' || *p
== '$'
1204 /* Characters used for XDB compatibility. */
1205 || (xdb_commands
&& (*p
== '/' || *p
== '?')))
1211 /* Return TRUE if NAME is a valid user-defined command name.
1212 This is a stricter subset of all gdb commands,
1213 see find_command_name_length. */
1216 valid_user_defined_cmd_name_p (const char *name
)
1223 /* Alas "42" is a legitimate user-defined command.
1224 In the interests of not breaking anything we preserve that. */
1226 for (p
= name
; *p
!= '\0'; ++p
)
1239 /* This routine takes a line of TEXT and a CLIST in which to start the
1240 lookup. When it returns it will have incremented the text pointer past
1241 the section of text it matched, set *RESULT_LIST to point to the list in
1242 which the last word was matched, and will return a pointer to the cmd
1243 list element which the text matches. It will return NULL if no match at
1244 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1245 matches are possible; in this case *RESULT_LIST will be set to point to
1246 the list in which there are ambiguous choices (and *TEXT will be set to
1247 the ambiguous text string).
1249 If the located command was an abbreviation, this routine returns the base
1250 command of the abbreviation.
1252 It does no error reporting whatsoever; control will always return
1253 to the superior routine.
1255 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1256 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1257 if no prefix command was ever found. For example, in the case of "info a",
1258 "info" matches without ambiguity, but "a" could be "args" or "address", so
1259 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1260 RESULT_LIST should not be interpeted as a pointer to the beginning of a
1261 list; it simply points to a specific command. In the case of an ambiguous
1262 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1263 "info t" can be "info types" or "info target"; upon return *TEXT has been
1264 advanced past "info ").
1266 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1267 affect the operation).
1269 This routine does *not* modify the text pointed to by TEXT.
1271 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1272 are actually help classes rather than commands (i.e. the function field of
1273 the struct cmd_list_element is NULL). */
1275 struct cmd_list_element
*
1276 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
1277 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1280 int len
, tmp
, nfound
;
1281 struct cmd_list_element
*found
, *c
;
1284 while (**text
== ' ' || **text
== '\t')
1287 /* Identify the name of the command. */
1288 len
= find_command_name_length (*text
);
1290 /* If nothing but whitespace, return 0. */
1294 /* *text and p now bracket the first command word to lookup (and
1295 it's length is len). We copy this into a local temporary. */
1298 command
= (char *) alloca (len
+ 1);
1299 memcpy (command
, *text
, len
);
1300 command
[len
] = '\0';
1305 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1307 /* We didn't find the command in the entered case, so lower case it
1308 and search again. */
1309 if (!found
|| nfound
== 0)
1311 for (tmp
= 0; tmp
< len
; tmp
++)
1313 char x
= command
[tmp
];
1315 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1317 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1320 /* If nothing matches, we have a simple failure. */
1326 if (result_list
!= NULL
)
1327 /* Will be modified in calling routine
1328 if we know what the prefix command is. */
1330 return CMD_LIST_AMBIGUOUS
; /* Ambiguous. */
1333 /* We've matched something on this list. Move text pointer forward. */
1337 if (found
->cmd_pointer
)
1339 /* We drop the alias (abbreviation) in favor of the command it
1340 is pointing to. If the alias is deprecated, though, we need to
1341 warn the user about it before we drop it. Note that while we
1342 are warning about the alias, we may also warn about the command
1343 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1346 if (found
->flags
& DEPRECATED_WARN_USER
)
1347 deprecated_cmd_warning (&line
);
1348 found
= found
->cmd_pointer
;
1350 /* If we found a prefix command, keep looking. */
1352 if (found
->prefixlist
)
1354 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1355 ignore_help_classes
);
1358 /* Didn't find anything; this is as far as we got. */
1359 if (result_list
!= NULL
)
1360 *result_list
= clist
;
1363 else if (c
== CMD_LIST_AMBIGUOUS
)
1365 /* We've gotten this far properly, but the next step is
1366 ambiguous. We need to set the result list to the best
1367 we've found (if an inferior hasn't already set it). */
1368 if (result_list
!= NULL
)
1370 /* This used to say *result_list = *found->prefixlist.
1371 If that was correct, need to modify the documentation
1372 at the top of this function to clarify what is
1373 supposed to be going on. */
1374 *result_list
= found
;
1385 if (result_list
!= NULL
)
1386 *result_list
= clist
;
1391 /* All this hair to move the space to the front of cmdtype */
1394 undef_cmd_error (char *cmdtype
, char *q
)
1396 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1399 *cmdtype
? " " : "",
1400 (int) strlen (cmdtype
) - 1,
1404 /* Look up the contents of *LINE as a command in the command list LIST.
1405 LIST is a chain of struct cmd_list_element's.
1406 If it is found, return the struct cmd_list_element for that command
1407 and update *LINE to point after the command name, at the first argument.
1408 If not found, call error if ALLOW_UNKNOWN is zero
1409 otherwise (or if error returns) return zero.
1410 Call error if specified command is ambiguous,
1411 unless ALLOW_UNKNOWN is negative.
1412 CMDTYPE precedes the word "command" in the error message.
1414 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1415 elements which are actually help classes rather than commands (i.e.
1416 the function field of the struct cmd_list_element is 0). */
1418 struct cmd_list_element
*
1419 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1420 int allow_unknown
, int ignore_help_classes
)
1422 struct cmd_list_element
*last_list
= 0;
1423 struct cmd_list_element
*c
;
1425 /* Note: Do not remove trailing whitespace here because this
1426 would be wrong for complete_command. Jim Kingdon */
1429 error (_("Lack of needed %scommand"), cmdtype
);
1431 c
= lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1438 int len
= find_command_name_length (*line
);
1440 q
= (char *) alloca (len
+ 1);
1441 strncpy (q
, *line
, len
);
1443 undef_cmd_error (cmdtype
, q
);
1448 else if (c
== CMD_LIST_AMBIGUOUS
)
1450 /* Ambigous. Local values should be off prefixlist or called
1452 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1454 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1455 struct cmd_list_element
*local_list
=
1456 (last_list
? *(last_list
->prefixlist
) : list
);
1458 if (local_allow_unknown
< 0)
1461 return last_list
; /* Found something. */
1463 return 0; /* Found nothing. */
1467 /* Report as error. */
1472 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1473 && (*line
)[amb_len
] != '\t');
1478 for (c
= local_list
; c
; c
= c
->next
)
1479 if (!strncmp (*line
, c
->name
, amb_len
))
1481 if (strlen (ambbuf
) + strlen (c
->name
) + 6
1482 < (int) sizeof ambbuf
)
1484 if (strlen (ambbuf
))
1485 strcat (ambbuf
, ", ");
1486 strcat (ambbuf
, c
->name
);
1490 strcat (ambbuf
, "..");
1494 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1496 return 0; /* lint */
1501 /* We've got something. It may still not be what the caller
1502 wants (if this command *needs* a subcommand). */
1503 while (**line
== ' ' || **line
== '\t')
1506 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1507 undef_cmd_error (c
->prefixname
, *line
);
1509 /* Seems to be what he wants. Return it. */
1515 /* We are here presumably because an alias or command in *TEXT is
1516 deprecated and a warning message should be generated. This
1517 function decodes *TEXT and potentially generates a warning message
1520 Example for 'set endian big' which has a fictitious alias 'seb'.
1522 If alias wasn't used in *TEXT, and the command is deprecated:
1523 "warning: 'set endian big' is deprecated."
1525 If alias was used, and only the alias is deprecated:
1526 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1528 If alias was used and command is deprecated (regardless of whether
1529 the alias itself is deprecated:
1531 "warning: 'set endian big' (seb) is deprecated."
1533 After the message has been sent, clear the appropriate flags in the
1534 command and/or the alias so the user is no longer bothered.
1538 deprecated_cmd_warning (char **text
)
1540 struct cmd_list_element
*alias
= NULL
;
1541 struct cmd_list_element
*prefix_cmd
= NULL
;
1542 struct cmd_list_element
*cmd
= NULL
;
1544 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1545 /* Return if text doesn't evaluate to a command. */
1548 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1549 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1550 /* Return if nothing is deprecated. */
1553 printf_filtered ("Warning:");
1555 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1556 printf_filtered (" '%s', an alias for the", alias
->name
);
1558 printf_filtered (" command '");
1561 printf_filtered ("%s", prefix_cmd
->prefixname
);
1563 printf_filtered ("%s", cmd
->name
);
1565 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1566 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1568 printf_filtered ("' is deprecated.\n");
1571 /* If it is only the alias that is deprecated, we want to indicate
1572 the new alias, otherwise we'll indicate the new command. */
1574 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1576 if (alias
->replacement
)
1577 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1579 printf_filtered ("No alternative known.\n\n");
1583 if (cmd
->replacement
)
1584 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1586 printf_filtered ("No alternative known.\n\n");
1589 /* We've warned you, now we'll keep quiet. */
1591 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1593 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1597 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1598 Return 1 on success, 0 on failure.
1600 If LINE refers to an alias, *alias will point to that alias.
1602 If LINE is a postfix command (i.e. one that is preceded by a prefix
1603 command) set *prefix_cmd.
1605 Set *cmd to point to the command LINE indicates.
1607 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1608 exist, they are NULL when we return.
1612 lookup_cmd_composition (char *text
,
1613 struct cmd_list_element
**alias
,
1614 struct cmd_list_element
**prefix_cmd
,
1615 struct cmd_list_element
**cmd
)
1618 int len
, tmp
, nfound
;
1619 struct cmd_list_element
*cur_list
;
1620 struct cmd_list_element
*prev_cmd
;
1630 /* Go through as many command lists as we need to,
1631 to find the command TEXT refers to. */
1635 while (*text
== ' ' || *text
== '\t')
1638 /* Identify the name of the command. */
1639 len
= find_command_name_length (text
);
1641 /* If nothing but whitespace, return. */
1645 /* Text is the start of the first command word to lookup (and
1646 it's length is len). We copy this into a local temporary. */
1648 command
= (char *) alloca (len
+ 1);
1649 memcpy (command
, text
, len
);
1650 command
[len
] = '\0';
1655 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1657 /* We didn't find the command in the entered case, so lower case
1658 it and search again.
1660 if (!*cmd
|| nfound
== 0)
1662 for (tmp
= 0; tmp
< len
; tmp
++)
1664 char x
= command
[tmp
];
1666 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1668 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1671 if (*cmd
== CMD_LIST_AMBIGUOUS
)
1673 return 0; /* ambiguous */
1677 return 0; /* nothing found */
1680 if ((*cmd
)->cmd_pointer
)
1682 /* cmd was actually an alias, we note that an alias was
1683 used (by assigning *alais) and we set *cmd. */
1685 *cmd
= (*cmd
)->cmd_pointer
;
1687 *prefix_cmd
= prev_cmd
;
1689 if ((*cmd
)->prefixlist
)
1690 cur_list
= *(*cmd
)->prefixlist
;
1698 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1700 /* Return a vector of char pointers which point to the different
1701 possible completions in LIST of TEXT.
1703 WORD points in the same buffer as TEXT, and completions should be
1704 returned relative to this position. For example, suppose TEXT is
1705 "foo" and we want to complete to "foobar". If WORD is "oo", return
1706 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1709 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1711 struct cmd_list_element
*ptr
;
1712 VEC (char_ptr
) *matchlist
= NULL
;
1713 int textlen
= strlen (text
);
1715 int saw_deprecated_match
= 0;
1717 /* We do one or two passes. In the first pass, we skip deprecated
1718 commands. If we see no matching commands in the first pass, and
1719 if we did happen to see a matching deprecated command, we do
1720 another loop to collect those. */
1721 for (pass
= 0; matchlist
== 0 && pass
< 2; ++pass
)
1723 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1724 if (!strncmp (ptr
->name
, text
, textlen
)
1725 && !ptr
->abbrev_flag
1727 || ptr
->prefixlist
))
1733 if ((ptr
->flags
& CMD_DEPRECATED
) != 0)
1735 saw_deprecated_match
= 1;
1740 match
= (char *) xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1742 strcpy (match
, ptr
->name
);
1743 else if (word
> text
)
1745 /* Return some portion of ptr->name. */
1746 strcpy (match
, ptr
->name
+ (word
- text
));
1750 /* Return some of text plus ptr->name. */
1751 strncpy (match
, word
, text
- word
);
1752 match
[text
- word
] = '\0';
1753 strcat (match
, ptr
->name
);
1755 VEC_safe_push (char_ptr
, matchlist
, match
);
1757 /* If we saw no matching deprecated commands in the first pass,
1759 if (!saw_deprecated_match
)
1766 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1768 /* Return a vector of char pointers which point to the different
1769 possible completions in CMD of TEXT.
1771 WORD points in the same buffer as TEXT, and completions should be
1772 returned relative to this position. For example, suppose TEXT is "foo"
1773 and we want to complete to "foobar". If WORD is "oo", return
1774 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1777 complete_on_enum (const char *const *enumlist
,
1781 VEC (char_ptr
) *matchlist
= NULL
;
1782 int textlen
= strlen (text
);
1786 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1787 if (strncmp (name
, text
, textlen
) == 0)
1791 match
= (char *) xmalloc (strlen (word
) + strlen (name
) + 1);
1793 strcpy (match
, name
);
1794 else if (word
> text
)
1796 /* Return some portion of name. */
1797 strcpy (match
, name
+ (word
- text
));
1801 /* Return some of text plus name. */
1802 strncpy (match
, word
, text
- word
);
1803 match
[text
- word
] = '\0';
1804 strcat (match
, name
);
1806 VEC_safe_push (char_ptr
, matchlist
, match
);
1813 /* Check function pointer. */
1815 cmd_func_p (struct cmd_list_element
*cmd
)
1817 return (cmd
->func
!= NULL
);
1821 /* Call the command function. */
1823 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1825 if (cmd_func_p (cmd
))
1826 (*cmd
->func
) (cmd
, args
, from_tty
);
1828 error (_("Invalid command"));