1 /* Handle lists of commands, their decoding and documentation, for GDB.
2 Copyright 1986, 1989, 1990, 1991, 1998, 2000 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
30 #include "gnu-regex.h"
31 /* FIXME: this should be auto-configured! */
36 /* Prototypes for local functions */
38 static void undef_cmd_error (char *, char *);
40 static void show_user (char *, int);
42 static void show_user_1 (struct cmd_list_element
*, struct ui_file
*);
44 static void make_command (char *, int);
46 static void shell_escape (char *, int);
48 static int parse_binary_operation (char *);
50 static void print_doc_line (struct ui_file
*, char *);
52 static struct cmd_list_element
*find_cmd (char *command
,
54 struct cmd_list_element
*clist
,
55 int ignore_help_classes
,
57 static void apropos_cmd_helper (struct ui_file
*, struct cmd_list_element
*,
58 struct re_pattern_buffer
*, char *);
60 static void help_all (struct ui_file
*stream
);
62 void apropos_command (char *, int);
64 void _initialize_command (void);
66 /* Add element named NAME.
67 CLASS is the top level category into which commands are broken down
69 FUN should be the function to execute the command;
70 it will get a character string as argument, with leading
71 and trailing blanks already eliminated.
73 DOC is a documentation string for the command.
74 Its first line should be a complete sentence.
75 It should start with ? for a command that is an abbreviation
76 or with * for a command that most users don't need to know about.
78 Add this command to command list *LIST.
80 Returns a pointer to the added command (not necessarily the head
83 struct cmd_list_element
*
84 add_cmd (name
, class, fun
, doc
, list
)
86 enum command_class
class;
87 void (*fun
) (char *, int);
89 struct cmd_list_element
**list
;
91 register struct cmd_list_element
*c
92 = (struct cmd_list_element
*) xmalloc (sizeof (struct cmd_list_element
));
93 struct cmd_list_element
*p
;
95 delete_cmd (name
, list
);
97 if (*list
== NULL
|| STRCMP ((*list
)->name
, name
) >= 0)
105 while (p
->next
&& STRCMP (p
->next
->name
, name
) <= 0)
115 c
->function
.cfunc
= fun
;
118 c
->replacement
= NULL
;
120 c
->prefixlist
= NULL
;
121 c
->prefixname
= NULL
;
122 c
->allow_unknown
= 0;
124 c
->completer
= make_symbol_completion_list
;
125 c
->type
= not_set_cmd
;
127 c
->var_type
= var_boolean
;
129 c
->user_commands
= NULL
;
131 c
->cmd_pointer
= NULL
;
137 /* Deprecates a command CMD.
138 REPLACEMENT is the name of the command which should be used in place
139 of this command, or NULL if no such command exists.
141 This function does not check to see if command REPLACEMENT exists
142 since gdb may not have gotten around to adding REPLACEMENT when this
145 Returns a pointer to the deprecated command. */
147 struct cmd_list_element
*
148 deprecate_cmd (cmd
, replacement
)
149 struct cmd_list_element
*cmd
;
152 cmd
->flags
|= (CMD_DEPRECATED
| DEPRECATED_WARN_USER
);
154 if (replacement
!= NULL
)
155 cmd
->replacement
= replacement
;
157 cmd
->replacement
= NULL
;
163 /* Same as above, except that the abbrev_flag is set. */
165 #if 0 /* Currently unused */
167 struct cmd_list_element
*
168 add_abbrev_cmd (name
, class, fun
, doc
, list
)
170 enum command_class
class;
171 void (*fun
) (char *, int);
173 struct cmd_list_element
**list
;
175 register struct cmd_list_element
*c
176 = add_cmd (name
, class, fun
, doc
, list
);
184 struct cmd_list_element
*
185 add_alias_cmd (name
, oldname
, class, abbrev_flag
, list
)
188 enum command_class
class;
190 struct cmd_list_element
**list
;
192 /* Must do this since lookup_cmd tries to side-effect its first arg */
194 register struct cmd_list_element
*old
;
195 register struct cmd_list_element
*c
;
196 copied_name
= (char *) alloca (strlen (oldname
) + 1);
197 strcpy (copied_name
, oldname
);
198 old
= lookup_cmd (&copied_name
, *list
, "", 1, 1);
202 delete_cmd (name
, list
);
206 c
= add_cmd (name
, class, old
->function
.cfunc
, old
->doc
, list
);
207 c
->prefixlist
= old
->prefixlist
;
208 c
->prefixname
= old
->prefixname
;
209 c
->allow_unknown
= old
->allow_unknown
;
210 c
->abbrev_flag
= abbrev_flag
;
211 c
->cmd_pointer
= old
;
215 /* Like add_cmd but adds an element for a command prefix:
216 a name that should be followed by a subcommand to be looked up
217 in another command list. PREFIXLIST should be the address
218 of the variable containing that list. */
220 struct cmd_list_element
*
221 add_prefix_cmd (name
, class, fun
, doc
, prefixlist
, prefixname
,
224 enum command_class
class;
225 void (*fun
) (char *, int);
227 struct cmd_list_element
**prefixlist
;
230 struct cmd_list_element
**list
;
232 register struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
233 c
->prefixlist
= prefixlist
;
234 c
->prefixname
= prefixname
;
235 c
->allow_unknown
= allow_unknown
;
239 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
241 struct cmd_list_element
*
242 add_abbrev_prefix_cmd (name
, class, fun
, doc
, prefixlist
, prefixname
,
245 enum command_class
class;
246 void (*fun
) (char *, int);
248 struct cmd_list_element
**prefixlist
;
251 struct cmd_list_element
**list
;
253 register struct cmd_list_element
*c
= add_cmd (name
, class, fun
, doc
, list
);
254 c
->prefixlist
= prefixlist
;
255 c
->prefixname
= prefixname
;
256 c
->allow_unknown
= allow_unknown
;
261 /* This is an empty "cfunc". */
263 not_just_help_class_command (args
, from_tty
)
269 /* This is an empty "sfunc". */
270 static void empty_sfunc (char *, int, struct cmd_list_element
*);
273 empty_sfunc (args
, from_tty
, c
)
276 struct cmd_list_element
*c
;
280 /* Add element named NAME to command list LIST (the list for set
281 or some sublist thereof).
282 CLASS is as in add_cmd.
283 VAR_TYPE is the kind of thing we are setting.
284 VAR is address of the variable being controlled by this command.
285 DOC is the documentation string. */
287 struct cmd_list_element
*
288 add_set_cmd (char *name
,
289 enum command_class
class,
293 struct cmd_list_element
**list
)
295 struct cmd_list_element
*c
296 = add_cmd (name
, class, NO_FUNCTION
, doc
, list
);
299 c
->var_type
= var_type
;
301 /* This needs to be something besides NO_FUNCTION so that this isn't
302 treated as a help class. */
303 c
->function
.sfunc
= empty_sfunc
;
307 /* Add element named NAME to command list LIST (the list for set
308 or some sublist thereof).
309 CLASS is as in add_cmd.
310 ENUMLIST is a list of strings which may follow NAME.
311 VAR is address of the variable which will contain the matching string
313 DOC is the documentation string. */
315 struct cmd_list_element
*
316 add_set_enum_cmd (char *name
,
317 enum command_class
class,
318 const char *enumlist
[],
321 struct cmd_list_element
**list
)
323 struct cmd_list_element
*c
324 = add_set_cmd (name
, class, var_enum
, var
, doc
, list
);
330 /* Add element named NAME to command list LIST (the list for set
331 or some sublist thereof).
332 CLASS is as in add_cmd.
333 VAR is address of the variable which will contain the value.
334 DOC is the documentation string. */
335 struct cmd_list_element
*
336 add_set_auto_boolean_cmd (char *name
,
337 enum command_class
class,
338 enum cmd_auto_boolean
*var
,
340 struct cmd_list_element
**list
)
342 static const char *auto_boolean_enums
[] = { "on", "off", "auto", NULL
};
343 struct cmd_list_element
*c
;
344 c
= add_set_cmd (name
, class, var_auto_boolean
, var
, doc
, list
);
345 c
->enums
= auto_boolean_enums
;
349 /* Where SETCMD has already been added, add the corresponding show
350 command to LIST and return a pointer to the added command (not
351 necessarily the head of LIST). */
352 struct cmd_list_element
*
353 add_show_from_set (setcmd
, list
)
354 struct cmd_list_element
*setcmd
;
355 struct cmd_list_element
**list
;
357 struct cmd_list_element
*showcmd
=
358 (struct cmd_list_element
*) xmalloc (sizeof (struct cmd_list_element
));
359 struct cmd_list_element
*p
;
361 memcpy (showcmd
, setcmd
, sizeof (struct cmd_list_element
));
362 delete_cmd (showcmd
->name
, list
);
363 showcmd
->type
= show_cmd
;
365 /* Replace "set " at start of docstring with "show ". */
366 if (setcmd
->doc
[0] == 'S' && setcmd
->doc
[1] == 'e'
367 && setcmd
->doc
[2] == 't' && setcmd
->doc
[3] == ' ')
368 showcmd
->doc
= concat ("Show ", setcmd
->doc
+ 4, NULL
);
370 fprintf_unfiltered (gdb_stderr
, "GDB internal error: Bad docstring for set command\n");
372 if (*list
== NULL
|| STRCMP ((*list
)->name
, showcmd
->name
) >= 0)
374 showcmd
->next
= *list
;
380 while (p
->next
&& STRCMP (p
->next
->name
, showcmd
->name
) <= 0)
384 showcmd
->next
= p
->next
;
391 /* Remove the command named NAME from the command list. */
394 delete_cmd (name
, list
)
396 struct cmd_list_element
**list
;
398 register struct cmd_list_element
*c
;
399 struct cmd_list_element
*p
;
401 while (*list
&& STREQ ((*list
)->name
, name
))
404 (*list
)->hookee
->hook
= 0; /* Hook slips out of its mouth */
411 for (c
= *list
; c
->next
;)
413 if (STREQ (c
->next
->name
, name
))
416 c
->next
->hookee
->hook
= 0; /* hooked cmd gets away. */
418 free ((PTR
) c
->next
);
425 /* Recursively walk the commandlist structures, and print out the
426 documentation of commands that match our regex in either their
427 name, or their documentation.
430 apropos_cmd_helper (struct ui_file
*stream
, struct cmd_list_element
*commandlist
,
431 struct re_pattern_buffer
*regex
, char *prefix
)
433 register struct cmd_list_element
*c
;
434 int returnvalue
=1; /*Needed to avoid double printing*/
435 /* Walk through the commands */
436 for (c
=commandlist
;c
;c
=c
->next
)
440 /* Try to match against the name*/
441 returnvalue
=re_search(regex
,c
->name
,strlen(c
->name
),0,strlen(c
->name
),NULL
);
442 if (returnvalue
>= 0)
444 /* Stolen from help_cmd_list. We don't directly use
445 * help_cmd_list because it doesn't let us print out
448 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
449 print_doc_line (stream
, c
->doc
);
450 fputs_filtered ("\n", stream
);
451 returnvalue
=0; /*Set this so we don't print it again.*/
454 if (c
->doc
!= NULL
&& returnvalue
!= 0)
456 /* Try to match against documentation */
457 if (re_search(regex
,c
->doc
,strlen(c
->doc
),0,strlen(c
->doc
),NULL
) >=0)
459 /* Stolen from help_cmd_list. We don't directly use
460 * help_cmd_list because it doesn't let us print out
463 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
464 print_doc_line (stream
, c
->doc
);
465 fputs_filtered ("\n", stream
);
468 /* Check if this command has subcommands */
469 if (c
->prefixlist
!= NULL
)
471 /* Recursively call ourselves on the subcommand list,
472 passing the right prefix in.
474 apropos_cmd_helper(stream
,*c
->prefixlist
,regex
,c
->prefixname
);
478 /* Search through names of commands and documentations for a certain
482 apropos_command (char *searchstr
, int from_tty
)
484 extern struct cmd_list_element
*cmdlist
; /*This is the main command list*/
486 char *pattern_fastmap
;
487 char errorbuffer
[512];
488 pattern_fastmap
=calloc(256,sizeof(char));
489 if (searchstr
== NULL
)
490 error("REGEXP string is empty");
492 if (regcomp(&pattern
,searchstr
,REG_ICASE
) == 0)
494 pattern
.fastmap
=pattern_fastmap
;
495 re_compile_fastmap(&pattern
);
496 apropos_cmd_helper(gdb_stdout
,cmdlist
,&pattern
,"");
500 regerror(regcomp(&pattern
,searchstr
,REG_ICASE
),NULL
,errorbuffer
,512);
501 error("Error in regular expression:%s",errorbuffer
);
503 free(pattern_fastmap
);
507 /* This command really has to deal with two things:
508 * 1) I want documentation on *this string* (usually called by
509 * "help commandname").
510 * 2) I want documentation on *this list* (usually called by
511 * giving a command that requires subcommands. Also called by saying
514 * I am going to split this into two seperate comamnds, help_cmd and
519 help_cmd (command
, stream
)
521 struct ui_file
*stream
;
523 struct cmd_list_element
*c
;
524 extern struct cmd_list_element
*cmdlist
;
528 help_list (cmdlist
, "", all_classes
, stream
);
532 if (strcmp (command
, "all") == 0)
538 c
= lookup_cmd (&command
, cmdlist
, "", 0, 0);
543 /* There are three cases here.
544 If c->prefixlist is nonzero, we have a prefix command.
545 Print its documentation, then list its subcommands.
547 If c->function is nonzero, we really have a command.
548 Print its documentation and return.
550 If c->function is zero, we have a class name.
551 Print its documentation (as if it were a command)
552 and then set class to the number of this class
553 so that the commands in the class will be listed. */
555 fputs_filtered (c
->doc
, stream
);
556 fputs_filtered ("\n", stream
);
558 if (c
->prefixlist
== 0 && c
->function
.cfunc
!= NULL
)
560 fprintf_filtered (stream
, "\n");
562 /* If this is a prefix command, print it's subcommands */
564 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, stream
);
566 /* If this is a class name, print all of the commands in the class */
567 if (c
->function
.cfunc
== NULL
)
568 help_list (cmdlist
, "", c
->class, stream
);
571 fprintf_filtered (stream
, "\nThis command has a hook defined: %s\n",
576 * Get a specific kind of help on a command list.
579 * CMDTYPE is the prefix to use in the title string.
580 * CLASS is the class with which to list the nodes of this list (see
581 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for
582 * everything, ALL_CLASSES for just classes, and non-negative for only things
583 * in a specific class.
584 * and STREAM is the output stream on which to print things.
585 * If you call this routine with a class >= 0, it recurses.
588 help_list (list
, cmdtype
, class, stream
)
589 struct cmd_list_element
*list
;
591 enum command_class
class;
592 struct ui_file
*stream
;
595 char *cmdtype1
, *cmdtype2
;
597 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */
598 len
= strlen (cmdtype
);
599 cmdtype1
= (char *) alloca (len
+ 1);
601 cmdtype2
= (char *) alloca (len
+ 4);
606 strncpy (cmdtype1
+ 1, cmdtype
, len
- 1);
608 strncpy (cmdtype2
, cmdtype
, len
- 1);
609 strcpy (cmdtype2
+ len
- 1, " sub");
612 if (class == all_classes
)
613 fprintf_filtered (stream
, "List of classes of %scommands:\n\n", cmdtype2
);
615 fprintf_filtered (stream
, "List of %scommands:\n\n", cmdtype2
);
617 help_cmd_list (list
, class, cmdtype
, (int) class >= 0, stream
);
619 if (class == all_classes
)
620 fprintf_filtered (stream
, "\n\
621 Type \"help%s\" followed by a class name for a list of commands in that class.",
624 fprintf_filtered (stream
, "\n\
625 Type \"help%s\" followed by %scommand name for full documentation.\n\
626 Command name abbreviations are allowed if unambiguous.\n",
631 help_all (struct ui_file
*stream
)
633 struct cmd_list_element
*c
;
634 extern struct cmd_list_element
*cmdlist
;
636 for (c
= cmdlist
; c
; c
= c
->next
)
640 /* If this is a prefix command, print it's subcommands */
642 help_cmd_list (*c
->prefixlist
, all_commands
, c
->prefixname
, 0, stream
);
644 /* If this is a class name, print all of the commands in the class */
645 else if (c
->function
.cfunc
== NULL
)
646 help_cmd_list (cmdlist
, c
->class, "", 0, stream
);
650 /* Print only the first line of STR on STREAM. */
652 print_doc_line (stream
, str
)
653 struct ui_file
*stream
;
656 static char *line_buffer
= 0;
657 static int line_size
;
663 line_buffer
= (char *) xmalloc (line_size
);
667 while (*p
&& *p
!= '\n' && *p
!= '.' && *p
!= ',')
669 if (p
- str
> line_size
- 1)
671 line_size
= p
- str
+ 1;
672 free ((PTR
) line_buffer
);
673 line_buffer
= (char *) xmalloc (line_size
);
675 strncpy (line_buffer
, str
, p
- str
);
676 line_buffer
[p
- str
] = '\0';
677 if (islower (line_buffer
[0]))
678 line_buffer
[0] = toupper (line_buffer
[0]);
680 ui_out_text (uiout
, line_buffer
);
682 fputs_filtered (line_buffer
, stream
);
687 * Implement a help command on command list LIST.
688 * RECURSE should be non-zero if this should be done recursively on
689 * all sublists of LIST.
690 * PREFIX is the prefix to print before each command name.
691 * STREAM is the stream upon which the output should be written.
693 * A non-negative class number to list only commands in that
695 * ALL_COMMANDS to list all commands in list.
696 * ALL_CLASSES to list all classes in list.
698 * Note that RECURSE will be active on *all* sublists, not just the
699 * ones selected by the criteria above (ie. the selection mechanism
700 * is at the low level, not the high-level).
703 help_cmd_list (list
, class, prefix
, recurse
, stream
)
704 struct cmd_list_element
*list
;
705 enum command_class
class;
708 struct ui_file
*stream
;
710 register struct cmd_list_element
*c
;
712 for (c
= list
; c
; c
= c
->next
)
714 if (c
->abbrev_flag
== 0 &&
715 (class == all_commands
716 || (class == all_classes
&& c
->function
.cfunc
== NULL
)
717 || (class == c
->class && c
->function
.cfunc
!= NULL
)))
719 fprintf_filtered (stream
, "%s%s -- ", prefix
, c
->name
);
720 print_doc_line (stream
, c
->doc
);
721 fputs_filtered ("\n", stream
);
724 && c
->prefixlist
!= 0
725 && c
->abbrev_flag
== 0)
726 help_cmd_list (*c
->prefixlist
, class, c
->prefixname
, 1, stream
);
731 /* Search the input clist for 'command'. Return the command if
732 found (or NULL if not), and return the number of commands
735 static struct cmd_list_element
*
736 find_cmd (command
, len
, clist
, ignore_help_classes
, nfound
)
739 struct cmd_list_element
*clist
;
740 int ignore_help_classes
;
743 struct cmd_list_element
*found
, *c
;
745 found
= (struct cmd_list_element
*) NULL
;
747 for (c
= clist
; c
; c
= c
->next
)
748 if (!strncmp (command
, c
->name
, len
)
749 && (!ignore_help_classes
|| c
->function
.cfunc
))
753 if (c
->name
[len
] == '\0')
762 /* This routine takes a line of TEXT and a CLIST in which to start the
763 lookup. When it returns it will have incremented the text pointer past
764 the section of text it matched, set *RESULT_LIST to point to the list in
765 which the last word was matched, and will return a pointer to the cmd
766 list element which the text matches. It will return NULL if no match at
767 all was possible. It will return -1 (cast appropriately, ick) if ambigous
768 matches are possible; in this case *RESULT_LIST will be set to point to
769 the list in which there are ambiguous choices (and *TEXT will be set to
770 the ambiguous text string).
772 If the located command was an abbreviation, this routine returns the base
773 command of the abbreviation.
775 It does no error reporting whatsoever; control will always return
776 to the superior routine.
778 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
779 at the prefix_command (ie. the best match) *or* (special case) will be NULL
780 if no prefix command was ever found. For example, in the case of "info a",
781 "info" matches without ambiguity, but "a" could be "args" or "address", so
782 *RESULT_LIST is set to the cmd_list_element for "info". So in this case
783 RESULT_LIST should not be interpeted as a pointer to the beginning of a
784 list; it simply points to a specific command. In the case of an ambiguous
785 return *TEXT is advanced past the last non-ambiguous prefix (e.g.
786 "info t" can be "info types" or "info target"; upon return *TEXT has been
787 advanced past "info ").
789 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
790 affect the operation).
792 This routine does *not* modify the text pointed to by TEXT.
794 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
795 are actually help classes rather than commands (i.e. the function field of
796 the struct cmd_list_element is NULL). */
798 struct cmd_list_element
*
799 lookup_cmd_1 (text
, clist
, result_list
, ignore_help_classes
)
801 struct cmd_list_element
*clist
, **result_list
;
802 int ignore_help_classes
;
805 int len
, tmp
, nfound
;
806 struct cmd_list_element
*found
, *c
;
809 while (**text
== ' ' || **text
== '\t')
812 /* Treating underscores as part of command words is important
813 so that "set args_foo()" doesn't get interpreted as
814 "set args _foo()". */
816 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
818 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
819 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
823 /* If nothing but whitespace, return 0. */
829 /* *text and p now bracket the first command word to lookup (and
830 it's length is len). We copy this into a local temporary */
833 command
= (char *) alloca (len
+ 1);
834 for (tmp
= 0; tmp
< len
; tmp
++)
836 char x
= (*text
)[tmp
];
844 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
847 ** We didn't find the command in the entered case, so lower case it
850 if (!found
|| nfound
== 0)
852 for (tmp
= 0; tmp
< len
; tmp
++)
854 char x
= command
[tmp
];
855 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
857 found
= find_cmd (command
, len
, clist
, ignore_help_classes
, &nfound
);
860 /* If nothing matches, we have a simple failure. */
866 if (result_list
!= NULL
)
867 /* Will be modified in calling routine
868 if we know what the prefix command is. */
870 return (struct cmd_list_element
*) -1; /* Ambiguous. */
873 /* We've matched something on this list. Move text pointer forward. */
877 if (found
->cmd_pointer
)
879 /* We drop the alias (abbreviation) in favor of the command it is
880 pointing to. If the alias is deprecated, though, we need to
881 warn the user about it before we drop it. Note that while we
882 are warning about the alias, we may also warn about the command
883 itself and we will adjust the appropriate DEPRECATED_WARN_USER
886 if (found
->flags
& DEPRECATED_WARN_USER
)
887 deprecated_cmd_warning (&line
);
888 found
= found
->cmd_pointer
;
890 /* If we found a prefix command, keep looking. */
892 if (found
->prefixlist
)
894 c
= lookup_cmd_1 (text
, *found
->prefixlist
, result_list
,
895 ignore_help_classes
);
898 /* Didn't find anything; this is as far as we got. */
899 if (result_list
!= NULL
)
900 *result_list
= clist
;
903 else if (c
== (struct cmd_list_element
*) -1)
905 /* We've gotten this far properly, but the next step
906 is ambiguous. We need to set the result list to the best
907 we've found (if an inferior hasn't already set it). */
908 if (result_list
!= NULL
)
910 /* This used to say *result_list = *found->prefixlist
911 If that was correct, need to modify the documentation
912 at the top of this function to clarify what is supposed
914 *result_list
= found
;
925 if (result_list
!= NULL
)
926 *result_list
= clist
;
931 /* All this hair to move the space to the front of cmdtype */
934 undef_cmd_error (cmdtype
, q
)
937 error ("Undefined %scommand: \"%s\". Try \"help%s%.*s\".",
941 strlen (cmdtype
) - 1,
945 /* Look up the contents of *LINE as a command in the command list LIST.
946 LIST is a chain of struct cmd_list_element's.
947 If it is found, return the struct cmd_list_element for that command
948 and update *LINE to point after the command name, at the first argument.
949 If not found, call error if ALLOW_UNKNOWN is zero
950 otherwise (or if error returns) return zero.
951 Call error if specified command is ambiguous,
952 unless ALLOW_UNKNOWN is negative.
953 CMDTYPE precedes the word "command" in the error message.
955 If INGNORE_HELP_CLASSES is nonzero, ignore any command list
956 elements which are actually help classes rather than commands (i.e.
957 the function field of the struct cmd_list_element is 0). */
959 struct cmd_list_element
*
960 lookup_cmd (line
, list
, cmdtype
, allow_unknown
, ignore_help_classes
)
962 struct cmd_list_element
*list
;
965 int ignore_help_classes
;
967 struct cmd_list_element
*last_list
= 0;
968 struct cmd_list_element
*c
=
969 lookup_cmd_1 (line
, list
, &last_list
, ignore_help_classes
);
971 /* This is wrong for complete_command. */
972 char *ptr
= (*line
) + strlen (*line
) - 1;
974 /* Clear off trailing whitespace. */
975 while (ptr
>= *line
&& (*ptr
== ' ' || *ptr
== '\t'))
985 error ("Lack of needed %scommand", cmdtype
);
990 while (isalnum (*p
) || *p
== '-')
993 q
= (char *) alloca (p
- *line
+ 1);
994 strncpy (q
, *line
, p
- *line
);
996 undef_cmd_error (cmdtype
, q
);
1002 else if (c
== (struct cmd_list_element
*) -1)
1004 /* Ambigous. Local values should be off prefixlist or called
1006 int local_allow_unknown
= (last_list
? last_list
->allow_unknown
:
1008 char *local_cmdtype
= last_list
? last_list
->prefixname
: cmdtype
;
1009 struct cmd_list_element
*local_list
=
1010 (last_list
? *(last_list
->prefixlist
) : list
);
1012 if (local_allow_unknown
< 0)
1015 return last_list
; /* Found something. */
1017 return 0; /* Found nothing. */
1021 /* Report as error. */
1026 ((*line
)[amb_len
] && (*line
)[amb_len
] != ' '
1027 && (*line
)[amb_len
] != '\t');
1032 for (c
= local_list
; c
; c
= c
->next
)
1033 if (!strncmp (*line
, c
->name
, amb_len
))
1035 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < (int) sizeof ambbuf
)
1037 if (strlen (ambbuf
))
1038 strcat (ambbuf
, ", ");
1039 strcat (ambbuf
, c
->name
);
1043 strcat (ambbuf
, "..");
1047 error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype
,
1049 return 0; /* lint */
1054 /* We've got something. It may still not be what the caller
1055 wants (if this command *needs* a subcommand). */
1056 while (**line
== ' ' || **line
== '\t')
1059 if (c
->prefixlist
&& **line
&& !c
->allow_unknown
)
1060 undef_cmd_error (c
->prefixname
, *line
);
1062 /* Seems to be what he wants. Return it. */
1068 /* We are here presumably because an alias or command in *TEXT is
1069 deprecated and a warning message should be generated. This function
1070 decodes *TEXT and potentially generates a warning message as outlined
1073 Example for 'set endian big' which has a fictitious alias 'seb'.
1075 If alias wasn't used in *TEXT, and the command is deprecated:
1076 "warning: 'set endian big' is deprecated."
1078 If alias was used, and only the alias is deprecated:
1079 "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1081 If alias was used and command is deprecated (regardless of whether the
1082 alias itself is deprecated:
1084 "warning: 'set endian big' (seb) is deprecated."
1086 After the message has been sent, clear the appropriate flags in the
1087 command and/or the alias so the user is no longer bothered.
1091 deprecated_cmd_warning (char **text
)
1093 struct cmd_list_element
*alias
= NULL
;
1094 struct cmd_list_element
*prefix_cmd
= NULL
;
1095 struct cmd_list_element
*cmd
= NULL
;
1096 struct cmd_list_element
*c
;
1099 if (!lookup_cmd_composition (*text
, &alias
, &prefix_cmd
, &cmd
))
1100 /* return if text doesn't evaluate to a command */
1103 if (!((alias
? (alias
->flags
& DEPRECATED_WARN_USER
) : 0)
1104 || (cmd
->flags
& DEPRECATED_WARN_USER
) ) )
1105 /* return if nothing is deprecated */
1108 printf_filtered ("Warning:");
1110 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1111 printf_filtered (" '%s', an alias for the", alias
->name
);
1113 printf_filtered (" command '");
1116 printf_filtered ("%s", prefix_cmd
->prefixname
);
1118 printf_filtered ("%s", cmd
->name
);
1120 if (alias
&& (cmd
->flags
& CMD_DEPRECATED
))
1121 printf_filtered ("' (%s) is deprecated.\n", alias
->name
);
1123 printf_filtered ("' is deprecated.\n");
1126 /* if it is only the alias that is deprecated, we want to indicate the
1127 new alias, otherwise we'll indicate the new command */
1129 if (alias
&& !(cmd
->flags
& CMD_DEPRECATED
))
1131 if (alias
->replacement
)
1132 printf_filtered ("Use '%s'.\n\n", alias
->replacement
);
1134 printf_filtered ("No alternative known.\n\n");
1138 if (cmd
->replacement
)
1139 printf_filtered ("Use '%s'.\n\n", cmd
->replacement
);
1141 printf_filtered ("No alternative known.\n\n");
1144 /* We've warned you, now we'll keep quiet */
1146 alias
->flags
&= ~DEPRECATED_WARN_USER
;
1148 cmd
->flags
&= ~DEPRECATED_WARN_USER
;
1153 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1154 Return 1 on success, 0 on failure.
1156 If LINE refers to an alias, *alias will point to that alias.
1158 If LINE is a postfix command (i.e. one that is preceeded by a prefix
1159 command) set *prefix_cmd.
1161 Set *cmd to point to the command LINE indicates.
1163 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1164 exist, they are NULL when we return.
1168 lookup_cmd_composition (char *text
,
1169 struct cmd_list_element
**alias
,
1170 struct cmd_list_element
**prefix_cmd
,
1171 struct cmd_list_element
**cmd
)
1174 int len
, tmp
, nfound
;
1175 struct cmd_list_element
*cur_list
;
1176 struct cmd_list_element
*prev_cmd
;
1185 /* Go through as many command lists as we need to
1186 to find the command TEXT refers to. */
1190 while (*text
== ' ' || *text
== '\t')
1193 /* Treating underscores as part of command words is important
1194 so that "set args_foo()" doesn't get interpreted as
1195 "set args _foo()". */
1197 *p
&& (isalnum (*p
) || *p
== '-' || *p
== '_' ||
1199 (*p
== '+' || *p
== '<' || *p
== '>' || *p
== '$')) ||
1200 (xdb_commands
&& (*p
== '!' || *p
== '/' || *p
== '?')));
1204 /* If nothing but whitespace, return. */
1210 /* text and p now bracket the first command word to lookup (and
1211 it's length is len). We copy this into a local temporary */
1213 command
= (char *) alloca (len
+ 1);
1214 for (tmp
= 0; tmp
< len
; tmp
++)
1219 command
[len
] = '\0';
1224 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1226 /* We didn't find the command in the entered case, so lower case it
1229 if (!*cmd
|| nfound
== 0)
1231 for (tmp
= 0; tmp
< len
; tmp
++)
1233 char x
= command
[tmp
];
1234 command
[tmp
] = isupper (x
) ? tolower (x
) : x
;
1236 *cmd
= find_cmd (command
, len
, cur_list
, 1, &nfound
);
1239 if (*cmd
== (struct cmd_list_element
*) -1)
1241 return 0; /* ambiguous */
1245 return 0; /* nothing found */
1248 if ((*cmd
)->cmd_pointer
)
1250 /* cmd was actually an alias, we note that an alias was used
1251 (by assigning *alais) and we set *cmd.
1254 *cmd
= (*cmd
)->cmd_pointer
;
1256 *prefix_cmd
= prev_cmd
;
1258 if ((*cmd
)->prefixlist
)
1259 cur_list
= *(*cmd
)->prefixlist
;
1271 /* Look up the contents of *LINE as a command in the command list LIST.
1272 LIST is a chain of struct cmd_list_element's.
1273 If it is found, return the struct cmd_list_element for that command
1274 and update *LINE to point after the command name, at the first argument.
1275 If not found, call error if ALLOW_UNKNOWN is zero
1276 otherwise (or if error returns) return zero.
1277 Call error if specified command is ambiguous,
1278 unless ALLOW_UNKNOWN is negative.
1279 CMDTYPE precedes the word "command" in the error message. */
1281 struct cmd_list_element
*
1282 lookup_cmd (line
, list
, cmdtype
, allow_unknown
)
1284 struct cmd_list_element
*list
;
1289 register struct cmd_list_element
*c
, *found
;
1292 char *processed_cmd
;
1295 /* Skip leading whitespace. */
1297 while (**line
== ' ' || **line
== '\t')
1300 /* Clear out trailing whitespace. */
1302 p
= *line
+ strlen (*line
);
1303 while (p
!= *line
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1307 /* Find end of command name. */
1310 while (*p
== '-' || isalnum (*p
))
1313 /* Look up the command name.
1314 If exact match, keep that.
1315 Otherwise, take command abbreviated, if unique. Note that (in my
1316 opinion) a null string does *not* indicate ambiguity; simply the
1317 end of the argument. */
1322 error ("Lack of needed %scommand", cmdtype
);
1326 /* Copy over to a local buffer, converting to lowercase on the way.
1327 This is in case the command being parsed is a subcommand which
1328 doesn't match anything, and that's ok. We want the original
1329 untouched for the routine of the original command. */
1331 processed_cmd
= (char *) alloca (p
- *line
+ 1);
1332 for (cmd_len
= 0; cmd_len
< p
- *line
; cmd_len
++)
1334 char x
= (*line
)[cmd_len
];
1336 processed_cmd
[cmd_len
] = tolower (x
);
1338 processed_cmd
[cmd_len
] = x
;
1340 processed_cmd
[cmd_len
] = '\0';
1342 /* Check all possibilities in the current command list. */
1345 for (c
= list
; c
; c
= c
->next
)
1347 if (!strncmp (processed_cmd
, c
->name
, cmd_len
))
1351 if (c
->name
[cmd_len
] == 0)
1359 /* Report error for undefined command name. */
1363 if (nfound
> 1 && allow_unknown
>= 0)
1366 for (c
= list
; c
; c
= c
->next
)
1367 if (!strncmp (processed_cmd
, c
->name
, cmd_len
))
1369 if (strlen (ambbuf
) + strlen (c
->name
) + 6 < sizeof ambbuf
)
1371 if (strlen (ambbuf
))
1372 strcat (ambbuf
, ", ");
1373 strcat (ambbuf
, c
->name
);
1377 strcat (ambbuf
, "..");
1381 error ("Ambiguous %scommand \"%s\": %s.", cmdtype
,
1382 processed_cmd
, ambbuf
);
1384 else if (!allow_unknown
)
1385 error ("Undefined %scommand: \"%s\".", cmdtype
, processed_cmd
);
1389 /* Skip whitespace before the argument. */
1391 while (*p
== ' ' || *p
== '\t')
1395 if (found
->prefixlist
&& *p
)
1397 c
= lookup_cmd (line
, *found
->prefixlist
, found
->prefixname
,
1398 found
->allow_unknown
);
1407 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1409 /* Return a vector of char pointers which point to the different
1410 possible completions in LIST of TEXT.
1412 WORD points in the same buffer as TEXT, and completions should be
1413 returned relative to this position. For example, suppose TEXT is "foo"
1414 and we want to complete to "foobar". If WORD is "oo", return
1415 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1418 complete_on_cmdlist (list
, text
, word
)
1419 struct cmd_list_element
*list
;
1423 struct cmd_list_element
*ptr
;
1425 int sizeof_matchlist
;
1427 int textlen
= strlen (text
);
1429 sizeof_matchlist
= 10;
1430 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1433 for (ptr
= list
; ptr
; ptr
= ptr
->next
)
1434 if (!strncmp (ptr
->name
, text
, textlen
)
1435 && !ptr
->abbrev_flag
1436 && (ptr
->function
.cfunc
1437 || ptr
->prefixlist
))
1439 if (matches
== sizeof_matchlist
)
1441 sizeof_matchlist
*= 2;
1442 matchlist
= (char **) xrealloc ((char *) matchlist
,
1444 * sizeof (char *)));
1447 matchlist
[matches
] = (char *)
1448 xmalloc (strlen (word
) + strlen (ptr
->name
) + 1);
1450 strcpy (matchlist
[matches
], ptr
->name
);
1451 else if (word
> text
)
1453 /* Return some portion of ptr->name. */
1454 strcpy (matchlist
[matches
], ptr
->name
+ (word
- text
));
1458 /* Return some of text plus ptr->name. */
1459 strncpy (matchlist
[matches
], word
, text
- word
);
1460 matchlist
[matches
][text
- word
] = '\0';
1461 strcat (matchlist
[matches
], ptr
->name
);
1468 free ((PTR
) matchlist
);
1473 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1474 * sizeof (char *)));
1475 matchlist
[matches
] = (char *) 0;
1481 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */
1483 /* Return a vector of char pointers which point to the different
1484 possible completions in CMD of TEXT.
1486 WORD points in the same buffer as TEXT, and completions should be
1487 returned relative to this position. For example, suppose TEXT is "foo"
1488 and we want to complete to "foobar". If WORD is "oo", return
1489 "oobar"; if WORD is "baz/foo", return "baz/foobar". */
1492 complete_on_enum (const char *enumlist
[],
1497 int sizeof_matchlist
;
1499 int textlen
= strlen (text
);
1503 sizeof_matchlist
= 10;
1504 matchlist
= (char **) xmalloc (sizeof_matchlist
* sizeof (char *));
1507 for (i
= 0; (name
= enumlist
[i
]) != NULL
; i
++)
1508 if (strncmp (name
, text
, textlen
) == 0)
1510 if (matches
== sizeof_matchlist
)
1512 sizeof_matchlist
*= 2;
1513 matchlist
= (char **) xrealloc ((char *) matchlist
,
1515 * sizeof (char *)));
1518 matchlist
[matches
] = (char *)
1519 xmalloc (strlen (word
) + strlen (name
) + 1);
1521 strcpy (matchlist
[matches
], name
);
1522 else if (word
> text
)
1524 /* Return some portion of name. */
1525 strcpy (matchlist
[matches
], name
+ (word
- text
));
1529 /* Return some of text plus name. */
1530 strncpy (matchlist
[matches
], word
, text
- word
);
1531 matchlist
[matches
][text
- word
] = '\0';
1532 strcat (matchlist
[matches
], name
);
1539 free ((PTR
) matchlist
);
1544 matchlist
= (char **) xrealloc ((char *) matchlist
, ((matches
+ 1)
1545 * sizeof (char *)));
1546 matchlist
[matches
] = (char *) 0;
1552 static enum cmd_auto_boolean
1553 parse_auto_binary_operation (const char *arg
)
1555 if (arg
!= NULL
&& *arg
!= '\0')
1557 int length
= strlen (arg
);
1558 while (isspace (arg
[length
- 1]) && length
> 0)
1560 if (strncmp (arg
, "on", length
) == 0
1561 || strncmp (arg
, "1", length
) == 0
1562 || strncmp (arg
, "yes", length
) == 0
1563 || strncmp (arg
, "enable", length
) == 0)
1564 return CMD_AUTO_BOOLEAN_TRUE
;
1565 else if (strncmp (arg
, "off", length
) == 0
1566 || strncmp (arg
, "0", length
) == 0
1567 || strncmp (arg
, "no", length
) == 0
1568 || strncmp (arg
, "disable", length
) == 0)
1569 return CMD_AUTO_BOOLEAN_FALSE
;
1570 else if (strncmp (arg
, "auto", length
) == 0
1571 || (strncmp (arg
, "-1", length
) == 0 && length
> 1))
1572 return CMD_AUTO_BOOLEAN_AUTO
;
1574 error ("\"on\", \"off\" or \"auto\" expected.");
1575 return CMD_AUTO_BOOLEAN_AUTO
; /* pacify GCC */
1579 parse_binary_operation (arg
)
1587 length
= strlen (arg
);
1589 while (arg
[length
- 1] == ' ' || arg
[length
- 1] == '\t')
1592 if (strncmp (arg
, "on", length
) == 0
1593 || strncmp (arg
, "1", length
) == 0
1594 || strncmp (arg
, "yes", length
) == 0
1595 || strncmp (arg
, "enable", length
) == 0)
1597 else if (strncmp (arg
, "off", length
) == 0
1598 || strncmp (arg
, "0", length
) == 0
1599 || strncmp (arg
, "no", length
) == 0
1600 || strncmp (arg
, "disable", length
) == 0)
1604 error ("\"on\" or \"off\" expected.");
1609 /* Do a "set" or "show" command. ARG is NULL if no argument, or the text
1610 of the argument, and FROM_TTY is nonzero if this command is being entered
1611 directly by the user (i.e. these are just like any other
1612 command). C is the command list element for the command. */
1614 do_setshow_command (arg
, from_tty
, c
)
1617 struct cmd_list_element
*c
;
1619 if (c
->type
== set_cmd
)
1621 switch (c
->var_type
)
1632 new = (char *) xmalloc (strlen (arg
) + 2);
1635 while ((ch
= *p
++) != '\000')
1639 /* \ at end of argument is used after spaces
1640 so they won't be lost. */
1641 /* This is obsolete now that we no longer strip
1642 trailing whitespace and actually, the backslash
1643 didn't get here in my test, readline or
1644 something did something funky with a backslash
1645 right before a newline. */
1648 ch
= parse_escape (&p
);
1650 break; /* C loses */
1658 if (*(p
- 1) != '\\')
1662 new = (char *) xrealloc (new, q
- new);
1663 if (*(char **) c
->var
!= NULL
)
1664 free (*(char **) c
->var
);
1665 *(char **) c
->var
= new;
1668 case var_string_noescape
:
1671 if (*(char **) c
->var
!= NULL
)
1672 free (*(char **) c
->var
);
1673 *(char **) c
->var
= savestring (arg
, strlen (arg
));
1677 error_no_arg ("filename to set it to.");
1678 if (*(char **) c
->var
!= NULL
)
1679 free (*(char **) c
->var
);
1680 *(char **) c
->var
= tilde_expand (arg
);
1683 *(int *) c
->var
= parse_binary_operation (arg
);
1685 case var_auto_boolean
:
1686 *(enum cmd_auto_boolean
*) c
->var
= parse_auto_binary_operation (arg
);
1690 error_no_arg ("integer to set it to.");
1691 *(unsigned int *) c
->var
= parse_and_eval_address (arg
);
1692 if (*(unsigned int *) c
->var
== 0)
1693 *(unsigned int *) c
->var
= UINT_MAX
;
1699 error_no_arg ("integer to set it to.");
1700 val
= parse_and_eval_address (arg
);
1702 *(int *) c
->var
= INT_MAX
;
1703 else if (val
>= INT_MAX
)
1704 error ("integer %u out of range", val
);
1706 *(int *) c
->var
= val
;
1711 error_no_arg ("integer to set it to.");
1712 *(int *) c
->var
= parse_and_eval_address (arg
);
1719 const char *match
= NULL
;
1722 /* if no argument was supplied, print an informative error message */
1726 strcpy (msg
, "Requires an argument. Valid arguments are ");
1727 for (i
= 0; c
->enums
[i
]; i
++)
1731 strcat (msg
, c
->enums
[i
]);
1737 p
= strchr (arg
, ' ');
1745 for (i
= 0; c
->enums
[i
]; i
++)
1746 if (strncmp (arg
, c
->enums
[i
], len
) == 0)
1748 if (c
->enums
[i
][len
] == '\0')
1750 match
= c
->enums
[i
];
1752 break; /* exact match. */
1756 match
= c
->enums
[i
];
1762 error ("Undefined item: \"%s\".", arg
);
1765 error ("Ambiguous item \"%s\".", arg
);
1767 *(const char **) c
->var
= match
;
1771 error ("gdb internal error: bad var_type in do_setshow_command");
1774 else if (c
->type
== show_cmd
)
1777 struct cleanup
*old_chain
;
1778 struct ui_stream
*stb
;
1781 stb
= ui_out_stream_new (uiout
);
1782 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1785 /* Print doc minus "show" at start. */
1786 print_doc_line (gdb_stdout
, c
->doc
+ 5);
1789 ui_out_text (uiout
, " is ");
1790 ui_out_wrap_hint (uiout
, " ");
1792 switch (c
->var_type
)
1798 if (*(unsigned char **) c
->var
)
1799 fputstr_filtered (*(unsigned char **) c
->var
, '"', stb
->stream
);
1803 case var_string_noescape
:
1806 if (*(char **) c
->var
)
1807 fputs_filtered (*(char **) c
->var
, stb
->stream
);
1811 fputs_filtered (*(int *) c
->var
? "on" : "off", stb
->stream
);
1813 case var_auto_boolean
:
1814 switch (*(enum auto_boolean
*) c
->var
)
1816 case CMD_AUTO_BOOLEAN_TRUE
:
1817 fputs_filtered ("on", stb
->stream
);
1819 case CMD_AUTO_BOOLEAN_FALSE
:
1820 fputs_filtered ("off", stb
->stream
);
1822 case CMD_AUTO_BOOLEAN_AUTO
:
1823 fputs_filtered ("auto", stb
->stream
);
1826 internal_error ("do_setshow_command: invalid var_auto_boolean");
1831 if (*(unsigned int *) c
->var
== UINT_MAX
)
1833 fputs_filtered ("unlimited", stb
->stream
);
1836 /* else fall through */
1838 fprintf_filtered (stb
->stream
, "%u", *(unsigned int *) c
->var
);
1841 if (*(int *) c
->var
== INT_MAX
)
1843 fputs_filtered ("unlimited", stb
->stream
);
1846 fprintf_filtered (stb
->stream
, "%d", *(int *) c
->var
);
1850 error ("gdb internal error: bad var_type in do_setshow_command");
1853 ui_out_text (uiout
, "\"");
1854 ui_out_field_stream (uiout
, "value", stb
);
1856 ui_out_text (uiout
, "\"");
1857 ui_out_text (uiout
, ".\n");
1858 do_cleanups (old_chain
);
1860 fputs_filtered (" is ", gdb_stdout
);
1862 switch (c
->var_type
)
1866 fputs_filtered ("\"", gdb_stdout
);
1867 if (*(unsigned char **) c
->var
)
1868 fputstr_filtered (*(unsigned char **) c
->var
, '"', gdb_stdout
);
1869 fputs_filtered ("\"", gdb_stdout
);
1872 case var_string_noescape
:
1875 fputs_filtered ("\"", gdb_stdout
);
1876 if (*(char **) c
->var
)
1877 fputs_filtered (*(char **) c
->var
, gdb_stdout
);
1878 fputs_filtered ("\"", gdb_stdout
);
1881 fputs_filtered (*(int *) c
->var
? "on" : "off", gdb_stdout
);
1883 case var_auto_boolean
:
1884 switch (*(enum cmd_auto_boolean
*) c
->var
)
1886 case CMD_AUTO_BOOLEAN_TRUE
:
1887 fputs_filtered ("on", gdb_stdout
);
1889 case CMD_AUTO_BOOLEAN_FALSE
:
1890 fputs_filtered ("off", gdb_stdout
);
1892 case CMD_AUTO_BOOLEAN_AUTO
:
1893 fputs_filtered ("auto", gdb_stdout
);
1896 internal_error ("do_setshow_command: invalid var_auto_boolean");
1901 if (*(unsigned int *) c
->var
== UINT_MAX
)
1903 fputs_filtered ("unlimited", gdb_stdout
);
1906 /* else fall through */
1908 fprintf_filtered (gdb_stdout
, "%u", *(unsigned int *) c
->var
);
1911 if (*(int *) c
->var
== INT_MAX
)
1913 fputs_filtered ("unlimited", gdb_stdout
);
1916 fprintf_filtered (gdb_stdout
, "%d", *(int *) c
->var
);
1920 error ("gdb internal error: bad var_type in do_setshow_command");
1922 fputs_filtered (".\n", gdb_stdout
);
1926 error ("gdb internal error: bad cmd_type in do_setshow_command");
1927 (*c
->function
.sfunc
) (NULL
, from_tty
, c
);
1928 if (c
->type
== set_cmd
&& set_hook
)
1932 /* Show all the settings in a list of show commands. */
1935 cmd_show_list (list
, from_tty
, prefix
)
1936 struct cmd_list_element
*list
;
1941 ui_out_list_begin (uiout
, "showlist");
1943 for (; list
!= NULL
; list
= list
->next
)
1945 /* If we find a prefix, run its list, prefixing our output by its
1946 prefix (with "show " skipped). */
1948 if (list
->prefixlist
&& !list
->abbrev_flag
)
1950 ui_out_list_begin (uiout
, "optionlist");
1951 ui_out_field_string (uiout
, "prefix", list
->prefixname
+ 5);
1952 cmd_show_list (*list
->prefixlist
, from_tty
, list
->prefixname
+ 5);
1953 ui_out_list_end (uiout
);
1955 if (list
->type
== show_cmd
)
1957 ui_out_list_begin (uiout
, "option");
1958 ui_out_text (uiout
, prefix
);
1959 ui_out_field_string (uiout
, "name", list
->name
);
1960 ui_out_text (uiout
, ": ");
1961 do_setshow_command ((char *) NULL
, from_tty
, list
);
1962 ui_out_list_end (uiout
);
1965 if (list
->prefixlist
&& !list
->abbrev_flag
)
1966 cmd_show_list (*list
->prefixlist
, from_tty
, list
->prefixname
+ 5);
1967 if (list
->type
== show_cmd
)
1969 fputs_filtered (prefix
, gdb_stdout
);
1970 fputs_filtered (list
->name
, gdb_stdout
);
1971 fputs_filtered (": ", gdb_stdout
);
1972 do_setshow_command ((char *) NULL
, from_tty
, list
);
1977 ui_out_list_end (uiout
);
1983 shell_escape (arg
, from_tty
)
1988 /* If ARG is NULL, they want an inferior shell, but `system' just
1989 reports if the shell is available when passed a NULL arg. */
1990 int rc
= system (arg
? arg
: "");
1993 arg
= "inferior shell";
1997 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
1998 safe_strerror (errno
));
1999 gdb_flush (gdb_stderr
);
2003 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
2004 gdb_flush (gdb_stderr
);
2007 /* Make sure to return to the directory GDB thinks it is, in case the
2008 shell command we just ran changed it. */
2009 chdir (current_directory
);
2011 #else /* Can fork. */
2012 int rc
, status
, pid
;
2013 char *p
, *user_shell
;
2015 if ((user_shell
= (char *) getenv ("SHELL")) == NULL
)
2016 user_shell
= "/bin/sh";
2018 /* Get the name of the shell for arg0 */
2019 if ((p
= strrchr (user_shell
, '/')) == NULL
)
2022 p
++; /* Get past '/' */
2024 if ((pid
= fork ()) == 0)
2027 execl (user_shell
, p
, 0);
2029 execl (user_shell
, p
, "-c", arg
, 0);
2031 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
2032 safe_strerror (errno
));
2033 gdb_flush (gdb_stderr
);
2038 while ((rc
= wait (&status
)) != pid
&& rc
!= -1)
2041 error ("Fork failed");
2042 #endif /* Can fork. */
2046 make_command (arg
, from_tty
)
2056 p
= xmalloc (sizeof ("make ") + strlen (arg
));
2057 strcpy (p
, "make ");
2058 strcpy (p
+ sizeof ("make ") - 1, arg
);
2061 shell_escape (p
, from_tty
);
2065 show_user_1 (c
, stream
)
2066 struct cmd_list_element
*c
;
2067 struct ui_file
*stream
;
2069 register struct command_line
*cmdlines
;
2071 cmdlines
= c
->user_commands
;
2074 fputs_filtered ("User command ", stream
);
2075 fputs_filtered (c
->name
, stream
);
2076 fputs_filtered (":\n", stream
);
2079 print_command_lines (uiout
, cmdlines
, 1);
2080 fputs_filtered ("\n", stream
);
2084 print_command_line (cmdlines
, 4, stream
);
2085 cmdlines
= cmdlines
->next
;
2087 fputs_filtered ("\n", stream
);
2093 show_user (args
, from_tty
)
2097 struct cmd_list_element
*c
;
2098 extern struct cmd_list_element
*cmdlist
;
2102 c
= lookup_cmd (&args
, cmdlist
, "", 0, 1);
2103 if (c
->class != class_user
)
2104 error ("Not a user command.");
2105 show_user_1 (c
, gdb_stdout
);
2109 for (c
= cmdlist
; c
; c
= c
->next
)
2111 if (c
->class == class_user
)
2112 show_user_1 (c
, gdb_stdout
);
2118 _initialize_command ()
2120 add_com ("shell", class_support
, shell_escape
,
2121 "Execute the rest of the line as a shell command. \n\
2122 With no arguments, run an inferior shell.");
2124 /* NOTE: cagney/2000-03-20: Being able to enter ``(gdb) !ls'' would
2125 be a really useful feature. Unfortunatly, the below wont do
2126 this. Instead it adds support for the form ``(gdb) ! ls''
2127 (i.e. the space is required). If the ``!'' command below is
2128 added the complains about no ``!'' command would be replaced by
2129 complains about how the ``!'' command is broken :-) */
2131 add_com_alias ("!", "shell", class_support
, 0);
2133 add_com ("make", class_support
, make_command
,
2134 "Run the ``make'' program using the rest of the line as arguments.");
2135 add_cmd ("user", no_class
, show_user
,
2136 "Show definitions of user defined commands.\n\
2137 Argument is the name of the user defined command.\n\
2138 With no argument, show definitions of all user defined commands.", &showlist
);
2139 add_com ("apropos", class_support
, apropos_command
, "Search for commands matching a REGEXP");