1 /* Handle lists of commands, their decoding and documentation, for GDB.
3 Copyright (c) 1986, 1989, 1990, 1991, 1998, 2000, 2001, 2002, 2004, 2007,
4 2008, 2009 Free 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
);
56 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
57 struct ui_file
*stream
);
60 /* Set the callback function for the specified command. For each both
61 the commands callback and func() are set. The latter set to a
62 bounce function (unless cfunc / sfunc is NULL that is). */
65 do_cfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
67 c
->function
.cfunc (args
, from_tty
); /* Ok. */
71 set_cmd_cfunc (struct cmd_list_element
*cmd
, cmd_cfunc_ftype
*cfunc
)
77 cmd
->function
.cfunc
= cfunc
; /* Ok. */
81 do_sfunc (struct cmd_list_element
*c
, char *args
, int from_tty
)
83 c
->function
.sfunc (args
, from_tty
, c
); /* Ok. */
87 set_cmd_sfunc (struct cmd_list_element
*cmd
, cmd_sfunc_ftype
*sfunc
)
93 cmd
->function
.sfunc
= sfunc
; /* Ok. */
97 cmd_cfunc_eq (struct cmd_list_element
*cmd
,
98 void (*cfunc
) (char *args
, int from_tty
))
100 return cmd
->func
== do_cfunc
&& cmd
->function
.cfunc
== cfunc
;
104 set_cmd_context (struct cmd_list_element
*cmd
, void *context
)
106 cmd
->context
= context
;
110 get_cmd_context (struct cmd_list_element
*cmd
)
116 set_cmd_no_selected_thread_ok (struct cmd_list_element
*cmd
)
118 cmd
->flags
|= CMD_NO_SELECTED_THREAD_OK
;
122 get_cmd_no_selected_thread_ok (struct cmd_list_element
*cmd
)
124 return cmd
->flags
& CMD_NO_SELECTED_THREAD_OK
;
128 cmd_type (struct cmd_list_element
*cmd
)
134 set_cmd_completer (struct cmd_list_element
*cmd
,
135 char **(*completer
) (char *text
, char *word
))
137 cmd
->completer
= completer
; /* Ok. */
141 /* Add element named NAME.
142 CLASS is the top level category into which commands are broken down
144 FUN should be the function to execute the command;
145 it will get a character string as argument, with leading
146 and trailing blanks already eliminated.
148 DOC is a documentation string for the command.
149 Its first line should be a complete sentence.
150 It should start with ? for a command that is an abbreviation
151 or with * for a command that most users don't need to know about.
153 Add this command to command list *LIST.
155 Returns a pointer to the added command (not necessarily the head
158 struct cmd_list_element
*
159 add_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
160 char *doc
, struct cmd_list_element
**list
)
162 struct cmd_list_element
*c
163 = (struct cmd_list_element
*) xmalloc (sizeof (struct cmd_list_element
));
164 struct cmd_list_element
*p
, *iter
;
166 /* Turn each alias of the old command into an alias of the new
168 c
->aliases
= delete_cmd (name
, list
, &c
->hook_pre
, &c
->hookee_pre
,
169 &c
->hook_post
, &c
->hookee_post
);
170 for (iter
= c
->aliases
; iter
; iter
= iter
->alias_chain
)
171 iter
->cmd_pointer
= c
;
173 c
->hook_pre
->hookee_pre
= c
;
175 c
->hookee_pre
->hook_pre
= c
;
177 c
->hook_post
->hookee_post
= c
;
179 c
->hookee_post
->hook_post
= c
;
181 if (*list
== NULL
|| strcmp ((*list
)->name
, name
) >= 0)
189 while (p
->next
&& strcmp (p
->next
->name
, name
) <= 0)
199 set_cmd_cfunc (c
, fun
);
200 set_cmd_context (c
, NULL
);
203 c
->replacement
= NULL
;
204 c
->pre_show_hook
= NULL
;
206 c
->prefixlist
= NULL
;
207 c
->prefixname
= NULL
;
208 c
->allow_unknown
= 0;
210 set_cmd_completer (c
, make_symbol_completion_list
);
211 c
->type
= not_set_cmd
;
213 c
->var_type
= var_boolean
;
215 c
->user_commands
= NULL
;
216 c
->cmd_pointer
= NULL
;
217 c
->alias_chain
= NULL
;
222 /* Deprecates a command CMD.
223 REPLACEMENT is the name of the command which should be used in place
224 of this command, or NULL if no such command exists.
226 This function does not check to see if command REPLACEMENT exists
227 since gdb may not have gotten around to adding REPLACEMENT when this
230 Returns a pointer to the deprecated command. */
232 struct cmd_list_element
*
233 deprecate_cmd (struct cmd_list_element
*cmd
, char *replacement
)
235 cmd
->flags
|= (CMD_DEPRECATED
| DEPRECATED_WARN_USER
);
237 if (replacement
!= NULL
)
238 cmd
->replacement
= replacement
;
240 cmd
->replacement
= NULL
;
245 struct cmd_list_element
*
246 add_alias_cmd (char *name
, char *oldname
, enum command_class
class,
247 int abbrev_flag
, struct cmd_list_element
**list
)
249 /* Must do this since lookup_cmd tries to side-effect its first arg */
251 struct cmd_list_element
*old
;
252 struct cmd_list_element
*c
;
253 copied_name
= (char *) alloca (strlen (oldname
) + 1);
254 strcpy (copied_name
, oldname
);
255 old
= lookup_cmd (&copied_name
, *list
, "", 1, 1);
259 struct cmd_list_element
*prehook
, *prehookee
, *posthook
, *posthookee
;
260 struct cmd_list_element
*aliases
= delete_cmd (name
, list
,
261 &prehook
, &prehookee
,
262 &posthook
, &posthookee
);
263 /* If this happens, it means a programmer error somewhere. */
264 gdb_assert (!aliases
&& !prehook
&& prehookee
265 && !posthook
&& ! posthookee
);
269 c
= add_cmd (name
, class, NULL
, old
->doc
, list
);
270 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */
272 c
->function
= old
->function
;
273 c
->prefixlist
= old
->prefixlist
;
274 c
->prefixname
= old
->prefixname
;
275 c
->allow_unknown
= old
->allow_unknown
;
276 c
->abbrev_flag
= abbrev_flag
;
277 c
->cmd_pointer
= old
;
278 c
->alias_chain
= old
->aliases
;
283 /* Like add_cmd but adds an element for a command prefix:
284 a name that should be followed by a subcommand to be looked up
285 in another command list. PREFIXLIST should be the address
286 of the variable containing that list. */
288 struct cmd_list_element
*
289 add_prefix_cmd (char *name
, enum command_class
class, void (*fun
) (char *, int),
290 char *doc
, struct cmd_list_element
**prefixlist
,
291 char *prefixname
, int allow_unknown
,
292 struct cmd_list_element
**list
)
294 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
295 c
->prefixlist
= prefixlist
;
296 c
->prefixname
= prefixname
;
297 c
->allow_unknown
= allow_unknown
;
301 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
303 struct cmd_list_element
*
304 add_abbrev_prefix_cmd (char *name
, enum command_class
class,
305 void (*fun
) (char *, int), char *doc
,
306 struct cmd_list_element
**prefixlist
, char *prefixname
,
307 int allow_unknown
, struct cmd_list_element
**list
)
309 struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
310 c
->prefixlist
= prefixlist
;
311 c
->prefixname
= prefixname
;
312 c
->allow_unknown
= allow_unknown
;
317 /* This is an empty "cfunc". */
319 not_just_help_class_command (char *args
, int from_tty
)
323 /* This is an empty "sfunc". */
324 static void empty_sfunc (char *, int, struct cmd_list_element
*);
327 empty_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
331 /* Add element named NAME to command list LIST (the list for set/show
332 or some sublist thereof).
333 TYPE is set_cmd or show_cmd.
334 CLASS is as in add_cmd.
335 VAR_TYPE is the kind of thing we are setting.
336 VAR is address of the variable being controlled by this command.
337 DOC is the documentation string. */
339 static struct cmd_list_element
*
340 add_set_or_show_cmd (char *name
,
342 enum command_class
class,
346 struct cmd_list_element
**list
)
348 struct cmd_list_element
*c
= add_cmd (name
, class, NULL
, doc
, list
);
349 gdb_assert (type
== set_cmd
|| type
== show_cmd
);
351 c
->var_type
= var_type
;
353 /* This needs to be something besides NULL so that this isn't
354 treated as a help class. */
355 set_cmd_sfunc (c
, empty_sfunc
);
359 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
360 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are
361 setting. VAR is address of the variable being controlled by this
362 command. SET_FUNC and SHOW_FUNC are the callback functions (if
363 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation
364 strings. PRINT the format string to print the value. SET_RESULT
365 and SHOW_RESULT, if not NULL, are set to the resulting command
369 add_setshow_cmd_full (char *name
,
370 enum command_class
class,
371 var_types var_type
, void *var
,
372 const char *set_doc
, const char *show_doc
,
373 const char *help_doc
,
374 cmd_sfunc_ftype
*set_func
,
375 show_value_ftype
*show_func
,
376 struct cmd_list_element
**set_list
,
377 struct cmd_list_element
**show_list
,
378 struct cmd_list_element
**set_result
,
379 struct cmd_list_element
**show_result
)
381 struct cmd_list_element
*set
;
382 struct cmd_list_element
*show
;
386 if (help_doc
!= NULL
)
388 full_set_doc
= xstrprintf ("%s\n%s", set_doc
, help_doc
);
389 full_show_doc
= xstrprintf ("%s\n%s", show_doc
, help_doc
);
393 full_set_doc
= xstrdup (set_doc
);
394 full_show_doc
= xstrdup (show_doc
);
396 set
= add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
,
397 full_set_doc
, set_list
);
398 if (set_func
!= NULL
)
399 set_cmd_sfunc (set
, set_func
);
400 show
= add_set_or_show_cmd (name
, show_cmd
, class, var_type
, var
,
401 full_show_doc
, show_list
);
402 show
->show_value_func
= show_func
;
404 if (set_result
!= NULL
)
406 if (show_result
!= NULL
)
410 struct cmd_list_element
*
411 deprecated_add_set_cmd (char *name
,
412 enum command_class
class,
416 struct cmd_list_element
**list
)
418 return add_set_or_show_cmd (name
, set_cmd
, class, var_type
, var
, doc
, list
);
421 /* Add element named NAME to command list LIST (the list for set or
422 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list
423 of strings which may follow NAME. VAR is address of the variable
424 which will contain the matching string (from ENUMLIST). */
427 add_setshow_enum_cmd (char *name
,
428 enum command_class
class,
429 const char *enumlist
[],
432 const char *show_doc
,
433 const char *help_doc
,
434 cmd_sfunc_ftype
*set_func
,
435 show_value_ftype
*show_func
,
436 struct cmd_list_element
**set_list
,
437 struct cmd_list_element
**show_list
)
439 struct cmd_list_element
*c
;
440 add_setshow_cmd_full (name
, class, var_enum
, var
,
441 set_doc
, show_doc
, help_doc
,
448 /* Add an auto-boolean command named NAME to both the set and show
449 command list lists. CLASS is as in add_cmd. VAR is address of the
450 variable which will contain the value. DOC is the documentation
451 string. FUNC is the corresponding callback. */
453 add_setshow_auto_boolean_cmd (char *name
,
454 enum command_class
class,
455 enum auto_boolean
*var
,
456 const char *set_doc
, const char *show_doc
,
457 const char *help_doc
,
458 cmd_sfunc_ftype
*set_func
,
459 show_value_ftype
*show_func
,
460 struct cmd_list_element
**set_list
,
461 struct cmd_list_element
**show_list
)
463 static const char *auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
464 struct cmd_list_element
*c
;
465 add_setshow_cmd_full (name
, class, var_auto_boolean
, var
,
466 set_doc
, show_doc
, help_doc
,
470 c
->enums
= auto_boolean_enums
;
473 /* Add element named NAME to both the set and show command LISTs (the
474 list for set/show or some sublist thereof). CLASS is as in
475 add_cmd. VAR is address of the variable which will contain the
476 value. SET_DOC and SHOW_DOC are the documentation strings. */
478 add_setshow_boolean_cmd (char *name
, enum command_class
class, int *var
,
479 const char *set_doc
, const char *show_doc
,
480 const char *help_doc
,
481 cmd_sfunc_ftype
*set_func
,
482 show_value_ftype
*show_func
,
483 struct cmd_list_element
**set_list
,
484 struct cmd_list_element
**show_list
)
486 static const char *boolean_enums
[] = { "on", "off", NULL
};
487 struct cmd_list_element
*c
;
488 add_setshow_cmd_full (name
, class, var_boolean
, var
,
489 set_doc
, show_doc
, help_doc
,
493 c
->enums
= boolean_enums
;
496 /* Add element named NAME to both the set and show command LISTs (the
497 list for set/show or some sublist thereof). */
499 add_setshow_filename_cmd (char *name
, enum command_class
class,
501 const char *set_doc
, const char *show_doc
,
502 const char *help_doc
,
503 cmd_sfunc_ftype
*set_func
,
504 show_value_ftype
*show_func
,
505 struct cmd_list_element
**set_list
,
506 struct cmd_list_element
**show_list
)
508 struct cmd_list_element
*set_result
;
509 add_setshow_cmd_full (name
, class, var_filename
, var
,
510 set_doc
, show_doc
, help_doc
,
514 set_cmd_completer (set_result
, filename_completer
);
517 /* Add element named NAME to both the set and show command LISTs (the
518 list for set/show or some sublist thereof). */
520 add_setshow_string_cmd (char *name
, enum command_class
class,
522 const char *set_doc
, const char *show_doc
,
523 const char *help_doc
,
524 cmd_sfunc_ftype
*set_func
,
525 show_value_ftype
*show_func
,
526 struct cmd_list_element
**set_list
,
527 struct cmd_list_element
**show_list
)
529 add_setshow_cmd_full (name
, class, var_string
, var
,
530 set_doc
, show_doc
, help_doc
,
536 /* Add element named NAME to both the set and show command LISTs (the
537 list for set/show or some sublist thereof). */
539 add_setshow_string_noescape_cmd (char *name
, enum command_class
class,
541 const char *set_doc
, const char *show_doc
,
542 const char *help_doc
,
543 cmd_sfunc_ftype
*set_func
,
544 show_value_ftype
*show_func
,
545 struct cmd_list_element
**set_list
,
546 struct cmd_list_element
**show_list
)
548 add_setshow_cmd_full (name
, class, var_string_noescape
, var
,
549 set_doc
, show_doc
, help_doc
,
555 /* Add element named NAME to both the set and show command LISTs (the
556 list for set/show or some sublist thereof). */
558 add_setshow_optional_filename_cmd (char *name
, enum command_class
class,
560 const char *set_doc
, const char *show_doc
,
561 const char *help_doc
,
562 cmd_sfunc_ftype
*set_func
,
563 show_value_ftype
*show_func
,
564 struct cmd_list_element
**set_list
,
565 struct cmd_list_element
**show_list
)
567 struct cmd_list_element
*set_result
;
569 add_setshow_cmd_full (name
, class, var_optional_filename
, var
,
570 set_doc
, show_doc
, help_doc
,
575 set_cmd_completer (set_result
, filename_completer
);
579 /* Add element named NAME to both the set and show command LISTs (the
580 list for set/show or some sublist thereof). CLASS is as in
581 add_cmd. VAR is address of the variable which will contain the
582 value. SET_DOC and SHOW_DOC are the documentation strings. */
584 add_setshow_integer_cmd (char *name
, enum command_class
class,
586 const char *set_doc
, const char *show_doc
,
587 const char *help_doc
,
588 cmd_sfunc_ftype
*set_func
,
589 show_value_ftype
*show_func
,
590 struct cmd_list_element
**set_list
,
591 struct cmd_list_element
**show_list
)
593 add_setshow_cmd_full (name
, class, var_integer
, var
,
594 set_doc
, show_doc
, help_doc
,
600 /* Add element named NAME to both the set and show command LISTs (the
601 list for set/show or some sublist thereof). CLASS is as in
602 add_cmd. VAR is address of the variable which will contain the
603 value. SET_DOC and SHOW_DOC are the documentation strings. */
605 add_setshow_uinteger_cmd (char *name
, enum command_class
class,
607 const char *set_doc
, const char *show_doc
,
608 const char *help_doc
,
609 cmd_sfunc_ftype
*set_func
,
610 show_value_ftype
*show_func
,
611 struct cmd_list_element
**set_list
,
612 struct cmd_list_element
**show_list
)
614 add_setshow_cmd_full (name
, class, var_uinteger
, var
,
615 set_doc
, show_doc
, help_doc
,
621 /* Add element named NAME to both the set and show command LISTs (the
622 list for set/show or some sublist thereof). CLASS is as in
623 add_cmd. VAR is address of the variable which will contain the
624 value. SET_DOC and SHOW_DOC are the documentation strings. */
626 add_setshow_zinteger_cmd (char *name
, enum command_class
class,
628 const char *set_doc
, const char *show_doc
,
629 const char *help_doc
,
630 cmd_sfunc_ftype
*set_func
,
631 show_value_ftype
*show_func
,
632 struct cmd_list_element
**set_list
,
633 struct cmd_list_element
**show_list
)
635 add_setshow_cmd_full (name
, class, var_zinteger
, var
,
636 set_doc
, show_doc
, help_doc
,
642 /* Remove the command named NAME from the command list. Return the
643 list commands which were aliased to the deleted command. If the
644 command had no aliases, return NULL. The various *HOOKs are set to
645 the pre- and post-hook commands for the deleted command. If the
646 command does not have a hook, the corresponding out parameter is
649 static struct cmd_list_element
*
650 delete_cmd (char *name
, struct cmd_list_element
**list
,
651 struct cmd_list_element
**prehook
,
652 struct cmd_list_element
**prehookee
,
653 struct cmd_list_element
**posthook
,
654 struct cmd_list_element
**posthookee
)
656 struct cmd_list_element
*iter
;
657 struct cmd_list_element
**previous_chain_ptr
;
658 struct cmd_list_element
*aliases
= NULL
;
664 previous_chain_ptr
= list
;
666 for (iter
= *previous_chain_ptr
; iter
; iter
= *previous_chain_ptr
)
668 if (strcmp (iter
->name
, name
) == 0)
670 if (iter
->hookee_pre
)
671 iter
->hookee_pre
->hook_pre
= 0;
672 *prehook
= iter
->hook_pre
;
673 *prehookee
= iter
->hookee_pre
;
674 if (iter
->hookee_post
)
675 iter
->hookee_post
->hook_post
= 0;
676 *posthook
= iter
->hook_post
;
677 *posthookee
= iter
->hookee_post
;
679 /* Update the link. */
680 *previous_chain_ptr
= iter
->next
;
682 aliases
= iter
->aliases
;
684 /* If this command was an alias, remove it from the list of
686 if (iter
->cmd_pointer
)
688 struct cmd_list_element
**prevp
= &iter
->cmd_pointer
->aliases
;
689 struct cmd_list_element
*a
= *prevp
;
693 prevp
= &a
->alias_chain
;
696 *prevp
= iter
->alias_chain
;
701 /* We won't see another command with the same name. */
705 previous_chain_ptr
= &iter
->next
;
711 /* Shorthands to the commands above. */
713 /* Add an element to the list of info subcommands. */
715 struct cmd_list_element
*
716 add_info (char *name
, void (*fun
) (char *, int), char *doc
)
718 return add_cmd (name
, no_class
, fun
, doc
, &infolist
);
721 /* Add an alias to the list of info subcommands. */
723 struct cmd_list_element
*
724 add_info_alias (char *name
, char *oldname
, int abbrev_flag
)
726 return add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
729 /* Add an element to the list of commands. */
731 struct cmd_list_element
*
732 add_com (char *name
, enum command_class
class, void (*fun
) (char *, int),
735 return add_cmd (name
, class, fun
, doc
, &cmdlist
);
738 /* Add an alias or abbreviation command to the list of commands. */
740 struct cmd_list_element
*
741 add_com_alias (char *name
, char *oldname
, enum command_class
class,
744 return add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
747 /* Recursively walk the commandlist structures, and print out the
748 documentation of commands that match our regex in either their
749 name, or their documentation.
752 apropos_cmd (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
753 struct re_pattern_buffer
*regex
, char *prefix
)
755 struct cmd_list_element
*c
;
756 int returnvalue
=1; /*Needed to avoid double printing*/
757 /* Walk through the commands */
758 for (c
=commandlist
;c
;c
=c
->next
)
762 /* Try to match against the name*/
763 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
764 if (returnvalue
>= 0)
766 print_help_for_command (c
, prefix
,
767 0 /* don't recurse */, stream
);
770 if (c
->doc
!= NULL
&& returnvalue
!= 0)
772 /* Try to match against documentation */
773 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
775 print_help_for_command (c
, prefix
,
776 0 /* don't recurse */, stream
);
779 /* Check if this command has subcommands */
780 if (c
->prefixlist
!= NULL
)
782 /* Recursively call ourselves on the subcommand list,
783 passing the right prefix in.
785 apropos_cmd (stream
,*c
->prefixlist
,regex
,c
->prefixname
);
790 /* This command really has to deal with two things:
791 * 1) I want documentation on *this string* (usually called by
792 * "help commandname").
793 * 2) I want documentation on *this list* (usually called by
794 * giving a command that requires subcommands. Also called by saying
797 * I am going to split this into two seperate comamnds, help_cmd and
802 help_cmd (char *command
, struct ui_file
*stream
)
804 struct cmd_list_element
*c
;
805 extern struct cmd_list_element
*cmdlist
;
809 help_list (cmdlist
, "", all_classes
, stream
);
813 if (strcmp (command
, "all") == 0)
819 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
824 /* There are three cases here.
825 If c->prefixlist is nonzero, we have a prefix command.
826 Print its documentation, then list its subcommands.
828 If c->func is non NULL, we really have a command. Print its
829 documentation and return.
831 If c->func is NULL, we have a class name. Print its
832 documentation (as if it were a command) and then set class to the
833 number of this class so that the commands in the class will be
836 fputs_filtered (c
->doc
, stream
);
837 fputs_filtered ("\n", stream
);
839 if (c
->prefixlist
== 0 && c
->func
!= NULL
)
841 fprintf_filtered (stream
, "\n");
843 /* If this is a prefix command, print it's subcommands */
845 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
847 /* If this is a class name, print all of the commands in the class */
849 help_list (cmdlist
, "", c
->class, stream
);
851 if (c
->hook_pre
|| c
->hook_post
)
852 fprintf_filtered (stream
,
853 "\nThis command has a hook (or hooks) defined:\n");
856 fprintf_filtered (stream
,
857 "\tThis command is run after : %s (pre hook)\n",
860 fprintf_filtered (stream
,
861 "\tThis command is run before : %s (post hook)\n",
866 * Get a specific kind of help on a command list.
869 * CMDTYPE is the prefix to use in the title string.
870 * CLASS is the class with which to list the nodes of this list (see
871 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
872 * everything, ALL_CLASSES for just classes, and non-negative for only things
873 * in a specific class.
874 * and STREAM is the output stream on which to print things.
875 * If you call this routine with a class >= 0, it recurses.
878 help_list (struct cmd_list_element
*list
, char *cmdtype
,
879 enum command_class
class, struct ui_file
*stream
)
882 char *cmdtype1
, *cmdtype2
;
884 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
885 len
= strlen (cmdtype
);
886 cmdtype1
= (char *) alloca (len
+ 1);
888 cmdtype2
= (char *) alloca (len
+ 4);
893 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
895 strncpy (cmdtype2
, cmdtype
, len
- 1);
896 strcpy (cmdtype2
+ len
- 1, " sub");
899 if (class == all_classes
)
900 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
902 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
904 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
906 if (class == all_classes
)
908 fprintf_filtered (stream
, "\n\
909 Type \"help%s\" followed by a class name for a list of commands in ",
912 fprintf_filtered (stream
, "that class.");
914 fprintf_filtered (stream
, "\n\
915 Type \"help all\" for the list of all commands.");
918 fprintf_filtered (stream
, "\nType \"help%s\" followed by %scommand name ",
921 fputs_filtered ("for ", stream
);
923 fputs_filtered ("full ", stream
);
925 fputs_filtered ("documentation.\n", stream
);
926 fputs_filtered ("Type \"apropos word\" to search "
927 "for commands related to \"word\".\n", stream
);
928 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
933 help_all (struct ui_file
*stream
)
935 struct cmd_list_element
*c
;
936 extern struct cmd_list_element
*cmdlist
;
937 int seen_unclassified
= 0;
939 for (c
= cmdlist
; c
; c
= c
->next
)
943 /* If this is a class name, print all of the commands in the class */
947 fprintf_filtered (stream
, "\nCommand class: %s\n\n", c
->name
);
948 help_cmd_list (cmdlist
, c
->class, "", 1, stream
);
952 /* While it's expected that all commands are in some class,
953 as a safety measure, we'll print commands outside of any
956 for (c
= cmdlist
; c
; c
= c
->next
)
961 if (c
->class == no_class
)
963 if (!seen_unclassified
)
965 fprintf_filtered (stream
, "\nUnclassified commands\n\n");
966 seen_unclassified
= 1;
968 print_help_for_command (c
, "", 1, stream
);
974 /* Print only the first line of STR on STREAM. */
976 print_doc_line (struct ui_file
*stream
, char *str
)
978 static char *line_buffer
= 0;
979 static int line_size
;
985 line_buffer
= (char *) xmalloc (line_size
);
989 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
991 if (p
- str
> line_size
- 1)
993 line_size
= p
- str
+ 1;
995 line_buffer
= (char *) xmalloc (line_size
);
997 strncpy (line_buffer
, str
, p
- str
);
998 line_buffer
[p
- str
] = '\0';
999 if (islower (line_buffer
[0]))
1000 line_buffer
[0] = toupper (line_buffer
[0]);
1001 ui_out_text (uiout
, line_buffer
);
1004 /* Print one-line help for command C.
1005 If RECURSE is non-zero, also print one-line descriptions
1006 of all prefixed subcommands. */
1008 print_help_for_command (struct cmd_list_element
*c
, char *prefix
, int recurse
,
1009 struct ui_file
*stream
)
1011 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
1012 print_doc_line (stream
, c
->doc
);
1013 fputs_filtered ("\n", stream
);
1016 && c
->prefixlist
!= 0
1017 && c
->abbrev_flag
== 0)
1018 /* Subcommands of a prefix command typically have 'all_commands'
1019 as class. If we pass CLASS to recursive invocation,
1020 most often we won't see anything. */
1021 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 1, stream
);
1025 * Implement a help command on command list LIST.
1026 * RECURSE should be non-zero if this should be done recursively on
1027 * all sublists of LIST.
1028 * PREFIX is the prefix to print before each command name.
1029 * STREAM is the stream upon which the output should be written.
1031 * A non-negative class number to list only commands in that
1033 * ALL_COMMANDS to list all commands in list.
1034 * ALL_CLASSES to list all classes in list.
1036 * Note that RECURSE will be active on *all* sublists, not just the
1037 * ones selected by the criteria above (ie. the selection mechanism
1038 * is at the low level, not the high-level).
1041 help_cmd_list (struct cmd_list_element
*list
, enum command_class
class,
1042 char *prefix
, int recurse
, struct ui_file
*stream
)
1044 struct cmd_list_element
*c
;
1046 for (c
= list
; c
; c
= c
->next
)
1048 if (c
->abbrev_flag
== 0 &&
1049 (class == all_commands
1050 || (class == all_classes
&& c
->func
== NULL
)
1051 || (class == c
->class && c
->func
!= NULL
)))
1053 print_help_for_command (c
, prefix
, recurse
, stream
);
1059 /* Search the input clist for 'command'. Return the command if
1060 found (or NULL if not), and return the number of commands
1063 static struct cmd_list_element
*
1064 find_cmd (char *command
, int len
, struct cmd_list_element
*clist
,
1065 int ignore_help_classes
, int *nfound
)
1067 struct cmd_list_element
*found
, *c
;
1069 found
= (struct cmd_list_element
*) NULL
;
1071 for (c
= clist
; c
; c
= c
->next
)
1072 if (!strncmp (command
, c
->name
, len
)
1073 && (!ignore_help_classes
|| c
->func
))
1077 if (c
->name
[len
] == '\0')
1087 find_command_name_length (const char *text
)
1089 const char *p
= text
;
1091 /* Treating underscores as part of command words is important
1092 so that "set args_foo()" doesn't get interpreted as
1093 "set args _foo()". */
1094 /* Some characters are only used for TUI specific commands. However, they
1095 are always allowed for the sake of consistency.
1096 The XDB compatibility characters are only allowed when using the right
1097 mode because they clash with other GDB commands - specifically '/' is
1098 used as a suffix for print, examine and display.
1099 Note that this is larger than the character set allowed when creating
1100 user-defined commands. */
1101 while (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1102 /* Characters used by TUI specific commands. */
1103 *p
== '+' || *p
== '<' || *p
== '>' || *p
== '$' ||
1104 /* Characters used for XDB compatibility. */
1105 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')))
1111 /* This routine takes a line of TEXT and a CLIST in which to start the
1112 lookup. When it returns it will have incremented the text pointer past
1113 the section of text it matched, set *RESULT_LIST to point to the list in
1114 which the last word was matched, and will return a pointer to the cmd
1115 list element which the text matches. It will return NULL if no match at
1116 all was possible. It will return -1 (cast appropriately, ick) if ambigous
1117 matches are possible; in this case *RESULT_LIST will be set to point to
1118 the list in which there are ambiguous choices (and *TEXT will be set to
1119 the ambiguous text string).
1121 If the located command was an abbreviation, this routine returns the base
1122 command of the abbreviation.
1124 It does no error reporting whatsoever; control will always return
1125 to the superior routine.
1127 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1128 at the prefix_command (ie. the best match) *or* (special case) will be NULL
1129 if no prefix command was ever found. For example, in the case of "info a",
1130 "info" matches without ambiguity, but "a" could be "args" or "address", so
1131 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
1132 RESULT_LIST should not be interpeted as a pointer to the beginning of a
1133 list; it simply points to a specific command. In the case of an ambiguous
1134 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1135 "info t" can be "info types" or "info target"; upon return *TEXT has been
1136 advanced past "info ").
1138 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1139 affect the operation).
1141 This routine does *not* modify the text pointed to by TEXT.
1143 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1144 are actually help classes rather than commands (i.e. the function field of
1145 the struct cmd_list_element is NULL). */
1147 struct cmd_list_element
*
1148 lookup_cmd_1 (char **text
, struct cmd_list_element
*clist
,
1149 struct cmd_list_element
**result_list
, int ignore_help_classes
)
1152 int len
, tmp
, nfound
;
1153 struct cmd_list_element
*found
, *c
;
1156 while (**text
== ' ' || **text
== '\t')
1159 /* Identify the name of the command. */
1160 len
= find_command_name_length (*text
);
1162 /* If nothing but whitespace, return 0. */
1166 /* *text and p now bracket the first command word to lookup (and
1167 it's length is len). We copy this into a local temporary */
1170 command
= (char *) alloca (len
+ 1);
1171 memcpy (command
, *text
, len
);
1172 command
[len
] = '\0';
1177 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1180 ** We didn't find the command in the entered case, so lower case it
1181 ** and search again.
1183 if (!found
|| nfound
== 0)
1185 for (tmp
= 0; tmp
< len
; tmp
++)
1187 char x
= command
[tmp
];
1188 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1190 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
1193 /* If nothing matches, we have a simple failure. */
1199 if (result_list
!= NULL
)
1200 /* Will be modified in calling routine
1201 if we know what the prefix command is. */
1203 return (struct cmd_list_element
*) -1; /* Ambiguous. */
1206 /* We've matched something on this list. Move text pointer forward. */
1210 if (found
->cmd_pointer
)
1212 /* We drop the alias (abbreviation) in favor of the command it is
1213 pointing to. If the alias is deprecated, though, we need to
1214 warn the user about it before we drop it. Note that while we
1215 are warning about the alias, we may also warn about the command
1216 itself and we will adjust the appropriate DEPRECATED_WARN_USER
1219 if (found
->flags
& DEPRECATED_WARN_USER
)
1220 deprecated_cmd_warning (&line
);
1221 found
= found
->cmd_pointer
;
1223 /* If we found a prefix command, keep looking. */
1225 if (found
->prefixlist
)
1227 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
1228 ignore_help_classes
);
1231 /* Didn't find anything; this is as far as we got. */
1232 if (result_list
!= NULL
)
1233 *result_list
= clist
;
1236 else if (c
== (struct cmd_list_element
*) -1)
1238 /* We've gotten this far properly, but the next step
1239 is ambiguous. We need to set the result list to the best
1240 we've found (if an inferior hasn't already set it). */
1241 if (result_list
!= NULL
)
1243 /* This used to say *result_list = *found->prefixlist
1244 If that was correct, need to modify the documentation
1245 at the top of this function to clarify what is supposed
1247 *result_list
= found
;
1258 if (result_list
!= NULL
)
1259 *result_list
= clist
;
1264 /* All this hair to move the space to the front of cmdtype */
1267 undef_cmd_error (char *cmdtype
, char *q
)
1269 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."),
1272 *cmdtype
? " " : "",
1273 (int) strlen (cmdtype
) - 1,
1277 /* Look up the contents of *LINE as a command in the command list LIST.
1278 LIST is a chain of struct cmd_list_element's.
1279 If it is found, return the struct cmd_list_element for that command
1280 and update *LINE to point after the command name, at the first argument.
1281 If not found, call error if ALLOW_UNKNOWN is zero
1282 otherwise (or if error returns) return zero.
1283 Call error if specified command is ambiguous,
1284 unless ALLOW_UNKNOWN is negative.
1285 CMDTYPE precedes the word "command" in the error message.
1287 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1288 elements which are actually help classes rather than commands (i.e.
1289 the function field of the struct cmd_list_element is 0). */
1291 struct cmd_list_element
*
1292 lookup_cmd (char **line
, struct cmd_list_element
*list
, char *cmdtype
,
1293 int allow_unknown
, int ignore_help_classes
)
1295 struct cmd_list_element
*last_list
= 0;
1296 struct cmd_list_element
*c
;
1298 /* Note: Do not remove trailing whitespace here because this
1299 would be wrong for complete_command. Jim Kingdon */
1302 error (_("Lack of needed %scommand"), cmdtype
);
1304 c
= lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
1311 int len
= find_command_name_length (*line
);
1313 q
= (char *) alloca (len
+ 1);
1314 strncpy (q
, *line
, len
);
1316 undef_cmd_error (cmdtype
, q
);
1321 else if (c
== (struct cmd_list_element
*) -1)
1323 /* Ambigous. Local values should be off prefixlist or called
1325 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1327 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1328 struct cmd_list_element
*local_list
=
1329 (last_list
? *(last_list
->prefixlist
) : list
);
1331 if (local_allow_unknown
< 0)
1334 return last_list
; /* Found something. */
1336 return 0; /* Found nothing. */
1340 /* Report as error. */
1345 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1346 && (*line
)[amb_len
] != '\t');
1351 for (c
= local_list
; c
; c
= c
->next
)
1352 if (!strncmp (*line
, c
->name
, amb_len
))
1354 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1356 if (strlen (ambbuf
))
1357 strcat (ambbuf
, ", ");
1358 strcat (ambbuf
, c
->name
);
1362 strcat (ambbuf
, "..");
1366 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype
,
1368 return 0; /* lint */
1373 /* We've got something. It may still not be what the caller
1374 wants (if this command *needs* a subcommand). */
1375 while (**line
== ' ' || **line
== '\t')
1378 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1379 undef_cmd_error (c
->prefixname
, *line
);
1381 /* Seems to be what he wants. Return it. */
1387 /* We are here presumably because an alias or command in *TEXT is
1388 deprecated and a warning message should be generated. This function
1389 decodes *TEXT and potentially generates a warning message as outlined
1392 Example for 'set endian big' which has a fictitious alias 'seb'.
1394 If alias wasn't used in *TEXT, and the command is deprecated:
1395 "warning: 'set endian big' is deprecated."
1397 If alias was used, and only the alias is deprecated:
1398 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1400 If alias was used and command is deprecated (regardless of whether the
1401 alias itself is deprecated:
1403 "warning: 'set endian big' (seb) is deprecated."
1405 After the message has been sent, clear the appropriate flags in the
1406 command and/or the alias so the user is no longer bothered.
1410 deprecated_cmd_warning (char **text
)
1412 struct cmd_list_element
*alias
= NULL
;
1413 struct cmd_list_element
*prefix_cmd
= NULL
;
1414 struct cmd_list_element
*cmd
= NULL
;
1415 struct cmd_list_element
*c
;
1418 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1419 /* return if text doesn't evaluate to a command */
1422 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1423 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1424 /* return if nothing is deprecated */
1427 printf_filtered ("Warning:");
1429 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1430 printf_filtered (" '%s', an alias for the", alias
->name
);
1432 printf_filtered (" command '");
1435 printf_filtered ("%s", prefix_cmd
->prefixname
);
1437 printf_filtered ("%s", cmd
->name
);
1439 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1440 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1442 printf_filtered ("' is deprecated.\n");
1445 /* if it is only the alias that is deprecated, we want to indicate the
1446 new alias, otherwise we'll indicate the new command */
1448 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1450 if (alias
->replacement
)
1451 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1453 printf_filtered ("No alternative known.\n\n");
1457 if (cmd
->replacement
)
1458 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1460 printf_filtered ("No alternative known.\n\n");
1463 /* We've warned you, now we'll keep quiet */
1465 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1467 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1472 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1473 Return 1 on success, 0 on failure.
1475 If LINE refers to an alias, *alias will point to that alias.
1477 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1478 command) set *prefix_cmd.
1480 Set *cmd to point to the command LINE indicates.
1482 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1483 exist, they are NULL when we return.
1487 lookup_cmd_composition (char *text
,
1488 struct cmd_list_element
**alias
,
1489 struct cmd_list_element
**prefix_cmd
,
1490 struct cmd_list_element
**cmd
)
1493 int len
, tmp
, nfound
;
1494 struct cmd_list_element
*cur_list
;
1495 struct cmd_list_element
*prev_cmd
;
1504 /* Go through as many command lists as we need to
1505 to find the command TEXT refers to. */
1509 while (*text
== ' ' || *text
== '\t')
1512 /* Identify the name of the command. */
1513 len
= find_command_name_length (text
);
1515 /* If nothing but whitespace, return. */
1519 /* text is the start of the first command word to lookup (and
1520 it's length is len). We copy this into a local temporary */
1522 command
= (char *) alloca (len
+ 1);
1523 memcpy (command
, text
, len
);
1524 command
[len
] = '\0';
1529 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1531 /* We didn't find the command in the entered case, so lower case it
1534 if (!*cmd
|| nfound
== 0)
1536 for (tmp
= 0; tmp
< len
; tmp
++)
1538 char x
= command
[tmp
];
1539 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1541 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1544 if (*cmd
== (struct cmd_list_element
*) -1)
1546 return 0; /* ambiguous */
1550 return 0; /* nothing found */
1553 if ((*cmd
)->cmd_pointer
)
1555 /* cmd was actually an alias, we note that an alias was used
1556 (by assigning *alais) and we set *cmd.
1559 *cmd
= (*cmd
)->cmd_pointer
;
1561 *prefix_cmd
= prev_cmd
;
1563 if ((*cmd
)->prefixlist
)
1564 cur_list
= *(*cmd
)->prefixlist
;
1572 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1574 /* Return a vector of char pointers which point to the different
1575 possible completions in LIST of TEXT.
1577 WORD points in the same buffer as TEXT, and completions should be
1578 returned relative to this position. For example, suppose TEXT is "foo"
1579 and we want to complete to "foobar". If WORD is "oo", return
1580 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1583 complete_on_cmdlist (struct cmd_list_element
*list
, char *text
, char *word
)
1585 struct cmd_list_element
*ptr
;
1587 int sizeof_matchlist
;
1589 int textlen
= strlen (text
);
1591 sizeof_matchlist
= 10;
1592 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1595 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1596 if (!strncmp (ptr
->name
, text
, textlen
)
1597 && !ptr
->abbrev_flag
1599 || ptr
->prefixlist
))
1601 if (matches
== sizeof_matchlist
)
1603 sizeof_matchlist
*= 2;
1604 matchlist
= (char **) xrealloc ((char *) matchlist
,
1606 * sizeof (char *)));
1609 matchlist
[matches
] = (char *)
1610 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1612 strcpy (matchlist
[matches
], ptr
->name
);
1613 else if (word
> text
)
1615 /* Return some portion of ptr->name. */
1616 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1620 /* Return some of text plus ptr->name. */
1621 strncpy (matchlist
[matches
], word
, text
- word
);
1622 matchlist
[matches
][text
- word
] = '\0';
1623 strcat (matchlist
[matches
], ptr
->name
);
1635 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1636 * sizeof (char *)));
1637 matchlist
[matches
] = (char *) 0;
1643 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1645 /* Return a vector of char pointers which point to the different
1646 possible completions in CMD of TEXT.
1648 WORD points in the same buffer as TEXT, and completions should be
1649 returned relative to this position. For example, suppose TEXT is "foo"
1650 and we want to complete to "foobar". If WORD is "oo", return
1651 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1654 complete_on_enum (const char *enumlist
[],
1659 int sizeof_matchlist
;
1661 int textlen
= strlen (text
);
1665 sizeof_matchlist
= 10;
1666 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1669 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1670 if (strncmp (name
, text
, textlen
) == 0)
1672 if (matches
== sizeof_matchlist
)
1674 sizeof_matchlist
*= 2;
1675 matchlist
= (char **) xrealloc ((char *) matchlist
,
1677 * sizeof (char *)));
1680 matchlist
[matches
] = (char *)
1681 xmalloc (strlen (word
) + strlen (name
) + 1);
1683 strcpy (matchlist
[matches
], name
);
1684 else if (word
> text
)
1686 /* Return some portion of name. */
1687 strcpy (matchlist
[matches
], name
+ (word
- text
));
1691 /* Return some of text plus name. */
1692 strncpy (matchlist
[matches
], word
, text
- word
);
1693 matchlist
[matches
][text
- word
] = '\0';
1694 strcat (matchlist
[matches
], name
);
1706 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1707 * sizeof (char *)));
1708 matchlist
[matches
] = (char *) 0;
1715 /* check function pointer */
1717 cmd_func_p (struct cmd_list_element
*cmd
)
1719 return (cmd
->func
!= NULL
);
1723 /* call the command function */
1725 cmd_func (struct cmd_list_element
*cmd
, char *args
, int from_tty
)
1727 if (cmd_func_p (cmd
))
1728 (*cmd
->func
) (cmd
, args
, from_tty
);
1730 error (_("Invalid command"));