3 Copyright (C) 2000-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
22 #include "readline/readline.h"
23 #include "readline/tilde.h"
24 #include "completer.h"
25 #include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
26 #include "gdbsupport/gdb_wait.h" /* For shell escape implementation. */
28 #include "gdb_regex.h" /* Used by apropos_command. */
29 #include "gdb_vfork.h"
31 #include "expression.h"
35 #include "filenames.h" /* For DOSish file names. */
39 #include "tracepoint.h"
40 #include "gdbsupport/filestuff.h"
48 #include "cli/cli-decode.h"
49 #include "cli/cli-script.h"
50 #include "cli/cli-setshow.h"
51 #include "cli/cli-cmds.h"
52 #include "cli/cli-style.h"
53 #include "cli/cli-utils.h"
55 #include "extension.h"
56 #include "gdbsupport/pathstuff.h"
59 #include "tui/tui.h" /* For tui_active et.al. */
66 /* Prototypes for local utility functions */
68 static void print_sal_location (const symtab_and_line
&sal
);
70 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
71 const char *format
, ...)
72 ATTRIBUTE_PRINTF (2, 3);
74 static void filter_sals (std::vector
<symtab_and_line
> &);
78 unsigned int max_user_call_depth
;
80 /* Define all cmd_list_elements. */
82 /* Chain containing all defined commands. */
84 struct cmd_list_element
*cmdlist
;
86 /* Chain containing all defined info subcommands. */
88 struct cmd_list_element
*infolist
;
90 /* Chain containing all defined enable subcommands. */
92 struct cmd_list_element
*enablelist
;
94 /* Chain containing all defined disable subcommands. */
96 struct cmd_list_element
*disablelist
;
98 /* Chain containing all defined stop subcommands. */
100 struct cmd_list_element
*stoplist
;
102 /* Chain containing all defined delete subcommands. */
104 struct cmd_list_element
*deletelist
;
106 /* Chain containing all defined detach subcommands. */
108 struct cmd_list_element
*detachlist
;
110 /* Chain containing all defined kill subcommands. */
112 struct cmd_list_element
*killlist
;
114 /* Chain containing all defined set subcommands */
116 struct cmd_list_element
*setlist
;
118 /* Chain containing all defined unset subcommands */
120 struct cmd_list_element
*unsetlist
;
122 /* Chain containing all defined show subcommands. */
124 struct cmd_list_element
*showlist
;
126 /* Chain containing all defined \"set history\". */
128 struct cmd_list_element
*sethistlist
;
130 /* Chain containing all defined \"show history\". */
132 struct cmd_list_element
*showhistlist
;
134 /* Chain containing all defined \"unset history\". */
136 struct cmd_list_element
*unsethistlist
;
138 /* Chain containing all defined maintenance subcommands. */
140 struct cmd_list_element
*maintenancelist
;
142 /* Chain containing all defined "maintenance info" subcommands. */
144 struct cmd_list_element
*maintenanceinfolist
;
146 /* Chain containing all defined "maintenance print" subcommands. */
148 struct cmd_list_element
*maintenanceprintlist
;
150 /* Chain containing all defined "maintenance check" subcommands. */
152 struct cmd_list_element
*maintenancechecklist
;
154 struct cmd_list_element
*setprintlist
;
156 struct cmd_list_element
*showprintlist
;
158 struct cmd_list_element
*setdebuglist
;
160 struct cmd_list_element
*showdebuglist
;
162 struct cmd_list_element
*setchecklist
;
164 struct cmd_list_element
*showchecklist
;
166 /* Command tracing state. */
168 int source_verbose
= 0;
169 bool trace_commands
= false;
171 /* 'script-extension' option support. */
173 static const char script_ext_off
[] = "off";
174 static const char script_ext_soft
[] = "soft";
175 static const char script_ext_strict
[] = "strict";
177 static const char *const script_ext_enums
[] = {
184 static const char *script_ext_mode
= script_ext_soft
;
186 /* Utility used everywhere when at least one argument is needed and
190 error_no_arg (const char *why
)
192 error (_("Argument required (%s)."), why
);
195 /* The "info" command is defined as a prefix, with allow_unknown = 0.
196 Therefore, its own definition is called only for "info" with no
200 info_command (const char *arg
, int from_tty
)
202 printf_unfiltered (_("\"info\" must be followed by "
203 "the name of an info command.\n"));
204 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
207 /* The "show" command with no arguments shows all the settings. */
210 show_command (const char *arg
, int from_tty
)
212 cmd_show_list (showlist
, from_tty
, "");
215 /* See cli/cli-cmds.h. */
218 with_command_1 (const char *set_cmd_prefix
,
219 cmd_list_element
*setlist
, const char *args
, int from_tty
)
222 error (_("Missing arguments."));
224 const char *delim
= strstr (args
, "--");
225 const char *nested_cmd
= nullptr;
228 error (_("Missing setting before '--' delimiter"));
230 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
231 nested_cmd
= repeat_previous ();
233 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
234 /*allow_unknown=*/ 0,
235 /*ignore_help_classes=*/ 1);
236 gdb_assert (set_cmd
!= nullptr);
238 if (set_cmd
->var
== nullptr)
239 error (_("Cannot use this setting with the \"with\" command"));
241 std::string temp_value
242 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
244 if (nested_cmd
== nullptr)
245 nested_cmd
= skip_spaces (delim
+ 2);
247 std::string org_value
= get_setshow_command_value_string (set_cmd
);
249 /* Tweak the setting to the new temporary value. */
250 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
254 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
256 /* Execute the nested command. */
257 execute_command (nested_cmd
, from_tty
);
259 catch (const gdb_exception
&ex
)
261 /* Restore the setting and rethrow. If restoring the setting
262 throws, swallow the new exception and warn. There's nothing
263 else we can reasonably do. */
266 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
268 catch (const gdb_exception
&ex2
)
270 warning (_("Couldn't restore setting: %s"), ex2
.what ());
276 /* Restore the setting. */
277 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
280 /* See cli/cli-cmds.h. */
283 with_command_completer_1 (const char *set_cmd_prefix
,
284 completion_tracker
&tracker
,
287 tracker
.set_use_custom_word_point (true);
289 const char *delim
= strstr (text
, "--");
291 /* If we're still not past the "--" delimiter, complete the "with"
292 command as if it was a "set" command. */
295 || !isspace (delim
[-1])
296 || !(isspace (delim
[2]) || delim
[2] == '\0'))
298 std::string new_text
= std::string (set_cmd_prefix
) + text
;
299 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
300 complete_nested_command_line (tracker
, new_text
.c_str ());
304 /* We're past the "--" delimiter. Complete on the sub command. */
305 const char *nested_cmd
= skip_spaces (delim
+ 2);
306 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
307 complete_nested_command_line (tracker
, nested_cmd
);
310 /* The "with" command. */
313 with_command (const char *args
, int from_tty
)
315 with_command_1 ("set ", setlist
, args
, from_tty
);
318 /* "with" command completer. */
321 with_command_completer (struct cmd_list_element
*ignore
,
322 completion_tracker
&tracker
,
323 const char *text
, const char * /*word*/)
325 with_command_completer_1 ("set ", tracker
, text
);
329 /* Provide documentation on command or list given by COMMAND. FROM_TTY
333 help_command (const char *command
, int from_tty
)
335 help_cmd (command
, gdb_stdout
);
339 /* Note: The "complete" command is used by Emacs to implement completion.
340 [Is that why this function writes output with *_unfiltered?] */
343 complete_command (const char *arg
, int from_tty
)
347 if (max_completions
== 0)
349 /* Only print this for non-mi frontends. An MI frontend may not
350 be able to handle this. */
351 if (!current_uiout
->is_mi_like_p ())
353 printf_unfiltered (_("max-completions is zero,"
354 " completion is disabled.\n"));
362 int quote_char
= '\0';
365 completion_result result
= complete (arg
, &word
, "e_char
);
367 if (result
.number_matches
!= 0)
369 std::string
arg_prefix (arg
, word
- arg
);
371 if (result
.number_matches
== 1)
372 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
375 result
.sort_match_list ();
377 for (size_t i
= 0; i
< result
.number_matches
; i
++)
379 printf_unfiltered ("%s%s",
381 result
.match_list
[i
+ 1]);
383 printf_unfiltered ("%c", quote_char
);
384 printf_unfiltered ("\n");
388 if (result
.number_matches
== max_completions
)
390 /* ARG_PREFIX and WORD are included in the output so that emacs
391 will include the message in the output. */
392 printf_unfiltered (_("%s%s %s\n"),
393 arg_prefix
.c_str (), word
,
394 get_max_completions_reached_message ());
400 is_complete_command (struct cmd_list_element
*c
)
402 return cmd_cfunc_eq (c
, complete_command
);
406 show_version (const char *args
, int from_tty
)
408 print_gdb_version (gdb_stdout
, true);
409 printf_filtered ("\n");
413 show_configuration (const char *args
, int from_tty
)
415 print_gdb_configuration (gdb_stdout
);
418 /* Handle the quit command. */
421 quit_command (const char *args
, int from_tty
)
425 /* An optional expression may be used to cause gdb to terminate with
426 the value of that expression. */
429 struct value
*val
= parse_and_eval (args
);
431 exit_code
= (int) value_as_long (val
);
434 if (!quit_confirm ())
435 error (_("Not confirmed."));
437 query_if_trace_running (from_tty
);
439 quit_force (args
? &exit_code
: NULL
, from_tty
);
443 pwd_command (const char *args
, int from_tty
)
446 error (_("The \"pwd\" command does not take an argument: %s"), args
);
448 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
451 error (_("Error finding name of working directory: %s"),
452 safe_strerror (errno
));
454 if (strcmp (cwd
.get (), current_directory
) != 0)
455 printf_unfiltered (_("Working directory %ps\n (canonically %ps).\n"),
456 styled_string (file_name_style
.style (),
458 styled_string (file_name_style
.style (), cwd
.get ()));
460 printf_unfiltered (_("Working directory %ps.\n"),
461 styled_string (file_name_style
.style (),
466 cd_command (const char *dir
, int from_tty
)
469 /* Found something other than leading repetitions of "/..". */
473 /* If the new directory is absolute, repeat is a no-op; if relative,
474 repeat might be useful but is more likely to be a mistake. */
477 gdb::unique_xmalloc_ptr
<char> dir_holder
478 (tilde_expand (dir
!= NULL
? dir
: "~"));
479 dir
= dir_holder
.get ();
482 perror_with_name (dir
);
484 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
485 /* There's too much mess with DOSish names like "d:", "d:.",
486 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
487 simply get the canonicalized name of the current directory. */
488 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
493 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
495 /* Remove the trailing slash unless this is a root directory
496 (including a drive letter on non-Unix systems). */
497 if (!(len
== 1) /* "/" */
498 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
499 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
505 dir_holder
.reset (savestring (dir
, len
));
506 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
508 xfree (current_directory
);
509 current_directory
= dir_holder
.release ();
513 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
514 current_directory
= concat (current_directory
, dir_holder
.get (),
517 current_directory
= concat (current_directory
, SLASH_STRING
,
518 dir_holder
.get (), (char *) NULL
);
521 /* Now simplify any occurrences of `.' and `..' in the pathname. */
524 for (p
= current_directory
; *p
;)
526 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
527 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
528 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
529 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
530 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
534 /* Search backwards for the directory just before the "/.."
535 and obliterate it and the "/..". */
538 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
541 if (q
== current_directory
)
542 /* current_directory is
543 a relative pathname ("can't happen"--leave it alone). */
547 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
552 /* We are dealing with leading repetitions of "/..", for
553 example "/../..", which is the Mach super-root. */
563 forget_cached_source_info ();
566 pwd_command ((char *) 0, 1);
569 /* Show the current value of the 'script-extension' option. */
572 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
573 struct cmd_list_element
*c
, const char *value
)
575 fprintf_filtered (file
,
576 _("Script filename extension recognition is \"%s\".\n"),
580 /* Try to open SCRIPT_FILE.
581 If successful, the full path name is stored in *FULL_PATHP,
582 and the stream is returned.
583 If not successful, return NULL; errno is set for the last file
586 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
587 search for it in the source search path. */
589 gdb::optional
<open_script
>
590 find_and_open_script (const char *script_file
, int search_path
)
593 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
594 gdb::optional
<open_script
> opened
;
596 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
599 search_flags
|= OPF_SEARCH_IN_PATH
;
601 /* Search for and open 'file' on the search path used for source
602 files. Put the full location in *FULL_PATHP. */
603 gdb::unique_xmalloc_ptr
<char> full_path
;
604 fd
= openp (source_path
, search_flags
,
605 file
.get (), O_RDONLY
, &full_path
);
610 FILE *result
= fdopen (fd
, FOPEN_RT
);
613 int save_errno
= errno
;
619 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
624 /* Load script FILE, which has already been opened as STREAM.
625 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
626 This is provided as FILE may have been found via the source search path.
627 An important thing to note here is that FILE may be a symlink to a file
628 with a different or non-existing suffix, and thus one cannot infer the
629 extension language from FILE_TO_OPEN. */
632 source_script_from_stream (FILE *stream
, const char *file
,
633 const char *file_to_open
)
635 if (script_ext_mode
!= script_ext_off
)
637 const struct extension_language_defn
*extlang
638 = get_ext_lang_of_file (file
);
642 if (ext_lang_present_p (extlang
))
644 script_sourcer_func
*sourcer
645 = ext_lang_script_sourcer (extlang
);
647 gdb_assert (sourcer
!= NULL
);
648 sourcer (extlang
, stream
, file_to_open
);
651 else if (script_ext_mode
== script_ext_soft
)
653 /* Assume the file is a gdb script.
654 This is handled below. */
657 throw_ext_lang_unsupported (extlang
);
661 script_from_file (stream
, file
);
664 /* Worker to perform the "source" command.
666 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
667 search for it in the source search path. */
670 source_script_with_search (const char *file
, int from_tty
, int search_path
)
673 if (file
== NULL
|| *file
== 0)
674 error (_("source command requires file name of file to source."));
676 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
679 /* The script wasn't found, or was otherwise inaccessible.
680 If the source command was invoked interactively, throw an
681 error. Otherwise (e.g. if it was invoked by a script),
682 just emit a warning, rather than cause an error. */
684 perror_with_name (file
);
687 perror_warning_with_name (file
);
692 /* The python support reopens the file, so we need to pass full_path here
693 in case the file was found on the search path. It's useful to do this
694 anyway so that error messages show the actual file used. But only do
695 this if we (may have) used search_path, as printing the full path in
696 errors for the non-search case can be more noise than signal. */
697 source_script_from_stream (opened
->stream
.get (), file
,
698 search_path
? opened
->full_path
.get () : file
);
701 /* Wrapper around source_script_with_search to export it to main.c
702 for use in loading .gdbinit scripts. */
705 source_script (const char *file
, int from_tty
)
707 source_script_with_search (file
, from_tty
, 0);
711 source_command (const char *args
, int from_tty
)
713 const char *file
= args
;
716 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
718 /* -v causes the source command to run in verbose mode.
719 -s causes the file to be searched in the source search path,
720 even if the file name contains a '/'.
721 We still have to be able to handle filenames with spaces in a
722 backward compatible way, so buildargv is not appropriate. */
726 while (args
[0] != '\0')
728 /* Make sure leading white space does not break the
730 args
= skip_spaces (args
);
735 if (args
[1] == 'v' && isspace (args
[2]))
739 /* Skip passed -v. */
742 else if (args
[1] == 's' && isspace (args
[2]))
746 /* Skip passed -s. */
753 file
= skip_spaces (args
);
756 source_script_with_search (file
, from_tty
, search_path
);
761 echo_command (const char *text
, int from_tty
)
763 const char *p
= text
;
767 while ((c
= *p
++) != '\0')
771 /* \ at end of argument is used after spaces
772 so they won't be lost. */
776 c
= parse_escape (get_current_arch (), &p
);
778 printf_filtered ("%c", c
);
781 printf_filtered ("%c", c
);
784 reset_terminal_style (gdb_stdout
);
786 /* Force this output to appear now. */
788 gdb_flush (gdb_stdout
);
791 /* Sets the last launched shell command convenience variables based on
795 exit_status_set_internal_vars (int exit_status
)
797 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
798 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
800 clear_internalvar (var_code
);
801 clear_internalvar (var_signal
);
802 if (WIFEXITED (exit_status
))
803 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
804 else if (WIFSIGNALED (exit_status
))
805 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
807 warning (_("unexpected shell command exit status %d"), exit_status
);
811 shell_escape (const char *arg
, int from_tty
)
813 #if defined(CANT_FORK) || \
814 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
815 /* If ARG is NULL, they want an inferior shell, but `system' just
816 reports if the shell is available when passed a NULL arg. */
817 int rc
= system (arg
? arg
: "");
820 arg
= "inferior shell";
823 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
824 safe_strerror (errno
));
826 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
828 /* Make sure to return to the directory GDB thinks it is, in case
829 the shell command we just ran changed it. */
830 chdir (current_directory
);
831 exit_status_set_internal_vars (rc
);
833 #else /* Can fork. */
836 if ((pid
= vfork ()) == 0)
838 const char *p
, *user_shell
= get_shell ();
842 /* Get the name of the shell for arg0. */
843 p
= lbasename (user_shell
);
846 execl (user_shell
, p
, (char *) 0);
848 execl (user_shell
, p
, "-c", arg
, (char *) 0);
850 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
851 safe_strerror (errno
));
856 waitpid (pid
, &status
, 0);
858 error (_("Fork failed"));
859 exit_status_set_internal_vars (status
);
860 #endif /* Can fork. */
863 /* Implementation of the "shell" command. */
866 shell_command (const char *arg
, int from_tty
)
868 shell_escape (arg
, from_tty
);
872 edit_command (const char *arg
, int from_tty
)
874 struct symtab_and_line sal
;
880 /* Pull in the current default source line if necessary. */
883 set_default_source_symtab_and_line ();
884 sal
= get_current_source_symtab_and_line ();
887 /* Bare "edit" edits file with present line. */
892 error (_("No default source file yet."));
893 sal
.line
+= get_lines_to_list () / 2;
899 /* Now should only be one argument -- decode it in SAL. */
901 event_location_up location
= string_to_event_location (&arg1
,
903 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
904 DECODE_LINE_LIST_MODE
,
913 if (sals
.size () > 1)
915 ambiguous_line_spec (sals
,
916 _("Specified line is ambiguous:\n"));
923 error (_("Junk at end of line specification."));
925 /* If line was specified by address, first print exactly which
926 line, and which file. In this case, sal.symtab == 0 means
927 address is outside of all known source files, not that user
928 failed to give a filename. */
931 struct gdbarch
*gdbarch
;
934 error (_("No source file for address %s."),
935 paddress (get_current_arch (), sal
.pc
));
937 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
938 sym
= find_pc_function (sal
.pc
);
940 printf_filtered ("%s is in %s (%s:%d).\n",
941 paddress (gdbarch
, sal
.pc
),
942 SYMBOL_PRINT_NAME (sym
),
943 symtab_to_filename_for_display (sal
.symtab
),
946 printf_filtered ("%s is at %s:%d.\n",
947 paddress (gdbarch
, sal
.pc
),
948 symtab_to_filename_for_display (sal
.symtab
),
952 /* If what was given does not imply a symtab, it must be an
953 undebuggable symbol which means no source code. */
956 error (_("No line number known for %s."), arg
);
959 if ((editor
= getenv ("EDITOR")) == NULL
)
962 fn
= symtab_to_fullname (sal
.symtab
);
964 /* Quote the file name, in case it has whitespace or other special
966 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
967 shell_escape (p
, from_tty
);
971 /* The options for the "pipe" command. */
976 char *delimiter
= nullptr;
984 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
986 gdb::option::string_option_def
<pipe_cmd_opts
> {
988 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
990 N_("Indicates to use the specified delimiter string to separate\n\
991 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
992 case COMMAND contains a | character."),
997 /* Create an option_def_group for the "pipe" command's options, with
1000 static inline gdb::option::option_def_group
1001 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
1003 return {{pipe_cmd_option_defs
}, opts
};
1006 /* Implementation of the "pipe" command. */
1009 pipe_command (const char *arg
, int from_tty
)
1013 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1014 gdb::option::process_options
1015 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1017 const char *delim
= "|";
1018 if (opts
.delimiter
!= nullptr)
1019 delim
= opts
.delimiter
;
1021 const char *command
= arg
;
1022 if (command
== nullptr)
1023 error (_("Missing COMMAND"));
1025 arg
= strstr (arg
, delim
);
1028 error (_("Missing delimiter before SHELL_COMMAND"));
1030 std::string
gdb_cmd (command
, arg
- command
);
1032 arg
+= strlen (delim
); /* Skip the delimiter. */
1034 if (gdb_cmd
.empty ())
1035 gdb_cmd
= repeat_previous ();
1037 const char *shell_command
= skip_spaces (arg
);
1038 if (*shell_command
== '\0')
1039 error (_("Missing SHELL_COMMAND"));
1041 FILE *to_shell_command
= popen (shell_command
, "w");
1043 if (to_shell_command
== nullptr)
1044 error (_("Error launching \"%s\""), shell_command
);
1048 stdio_file
pipe_file (to_shell_command
);
1050 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1054 pclose (to_shell_command
);
1058 int exit_status
= pclose (to_shell_command
);
1060 if (exit_status
< 0)
1061 error (_("shell command \"%s\" failed: %s"), shell_command
,
1062 safe_strerror (errno
));
1063 exit_status_set_internal_vars (exit_status
);
1066 /* Completer for the pipe command. */
1069 pipe_command_completer (struct cmd_list_element
*ignore
,
1070 completion_tracker
&tracker
,
1071 const char *text
, const char *word_ignored
)
1075 const char *org_text
= text
;
1076 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1077 if (gdb::option::complete_options
1078 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1081 const char *delimiter
= "|";
1082 if (opts
.delimiter
!= nullptr)
1083 delimiter
= opts
.delimiter
;
1085 /* Check if we're past option values already. */
1086 if (text
> org_text
&& !isspace (text
[-1]))
1089 const char *delim
= strstr (text
, delimiter
);
1091 /* If we're still not past the delimiter, complete the gdb
1093 if (delim
== nullptr || delim
== text
)
1095 complete_nested_command_line (tracker
, text
);
1099 /* We're past the delimiter. What follows is a shell command, which
1100 we don't know how to complete. */
1104 list_command (const char *arg
, int from_tty
)
1111 int linenum_beg
= 0;
1114 /* Pull in the current default source line if necessary. */
1115 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1117 set_default_source_symtab_and_line ();
1118 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1120 /* If this is the first "list" since we've set the current
1121 source line, center the listing around that line. */
1122 if (get_first_line_listed () == 0)
1126 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1128 /* A small special case --- if listing backwards, and we
1129 should list only one line, list the preceding line,
1130 instead of the exact line we've just shown after e.g.,
1131 stopping for a breakpoint. */
1132 if (arg
!= NULL
&& arg
[0] == '-'
1133 && get_lines_to_list () == 1 && first
> 1)
1136 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1139 /* "l" or "l +" lists next ten lines. */
1140 else if (arg
== NULL
|| arg
[0] == '+')
1141 print_source_lines (cursal
.symtab
,
1142 source_lines_range (cursal
.line
), 0);
1144 /* "l -" lists previous ten lines, the ones before the ten just
1146 else if (arg
[0] == '-')
1148 if (get_first_line_listed () == 1)
1149 error (_("Already at the start of %s."),
1150 symtab_to_filename_for_display (cursal
.symtab
));
1151 source_lines_range
range (get_first_line_listed (),
1152 source_lines_range::BACKWARD
);
1153 print_source_lines (cursal
.symtab
, range
, 0);
1159 /* Now if there is only one argument, decode it in SAL
1161 If there are two arguments, decode them in SAL and SAL_END
1162 and clear NO_END; however, if one of the arguments is blank,
1163 set DUMMY_BEG or DUMMY_END to record that fact. */
1165 if (!have_full_symbols () && !have_partial_symbols ())
1166 error (_("No symbol table is loaded. Use the \"file\" command."));
1168 std::vector
<symtab_and_line
> sals
;
1169 symtab_and_line sal
, sal_end
;
1176 event_location_up location
= string_to_event_location (&arg1
,
1178 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1190 /* Record whether the BEG arg is all digits. */
1192 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1193 linenum_beg
= (p
== arg1
);
1195 /* Save the range of the first argument, in case we need to let the
1196 user know it was ambiguous. */
1197 const char *beg
= arg
;
1198 size_t beg_len
= arg1
- beg
;
1200 while (*arg1
== ' ' || *arg1
== '\t')
1205 if (sals
.size () > 1)
1207 ambiguous_line_spec (sals
,
1208 _("Specified first line '%.*s' is ambiguous:\n"),
1209 (int) beg_len
, beg
);
1213 while (*arg1
== ' ' || *arg1
== '\t')
1219 /* Save the last argument, in case we need to let the user
1220 know it was ambiguous. */
1221 const char *end_arg
= arg1
;
1223 event_location_up location
1224 = string_to_event_location (&arg1
, current_language
);
1226 std::vector
<symtab_and_line
> sals_end
1228 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1230 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1231 NULL
, sal
.symtab
, sal
.line
));
1233 filter_sals (sals_end
);
1234 if (sals_end
.empty ())
1236 if (sals_end
.size () > 1)
1238 ambiguous_line_spec (sals_end
,
1239 _("Specified last line '%s' is ambiguous:\n"),
1243 sal_end
= sals_end
[0];
1248 error (_("Junk at end of line specification."));
1250 if (!no_end
&& !dummy_beg
&& !dummy_end
1251 && sal
.symtab
!= sal_end
.symtab
)
1252 error (_("Specified first and last lines are in different files."));
1253 if (dummy_beg
&& dummy_end
)
1254 error (_("Two empty args do not say what lines to list."));
1256 /* If line was specified by address,
1257 first print exactly which line, and which file.
1259 In this case, sal.symtab == 0 means address is outside of all
1260 known source files, not that user failed to give a filename. */
1263 struct gdbarch
*gdbarch
;
1265 if (sal
.symtab
== 0)
1266 error (_("No source file for address %s."),
1267 paddress (get_current_arch (), sal
.pc
));
1269 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1270 sym
= find_pc_function (sal
.pc
);
1272 printf_filtered ("%s is in %s (%s:%d).\n",
1273 paddress (gdbarch
, sal
.pc
),
1274 SYMBOL_PRINT_NAME (sym
),
1275 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1277 printf_filtered ("%s is at %s:%d.\n",
1278 paddress (gdbarch
, sal
.pc
),
1279 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1282 /* If line was not specified by just a line number, and it does not
1283 imply a symtab, it must be an undebuggable symbol which means no
1286 if (!linenum_beg
&& sal
.symtab
== 0)
1287 error (_("No line number known for %s."), arg
);
1289 /* If this command is repeated with RET,
1290 turn it into the no-arg variant. */
1293 set_repeat_arguments ("");
1295 if (dummy_beg
&& sal_end
.symtab
== 0)
1296 error (_("No default source file yet. Do \"help list\"."));
1299 source_lines_range
range (sal_end
.line
+ 1,
1300 source_lines_range::BACKWARD
);
1301 print_source_lines (sal_end
.symtab
, range
, 0);
1303 else if (sal
.symtab
== 0)
1304 error (_("No default source file yet. Do \"help list\"."));
1307 for (int i
= 0; i
< sals
.size (); i
++)
1310 int first_line
= sal
.line
- get_lines_to_list () / 2;
1313 if (sals
.size () > 1)
1314 print_sal_location (sal
);
1315 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1319 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1321 print_source_lines (sal
.symtab
,
1322 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1326 /* Subroutine of disassemble_command to simplify it.
1327 Perform the disassembly.
1328 NAME is the name of the function if known, or NULL.
1329 [LOW,HIGH) are the range of addresses to disassemble.
1330 BLOCK is the block to disassemble; it needs to be provided
1331 when non-contiguous blocks are disassembled; otherwise
1333 MIXED is non-zero to print source with the assembler. */
1336 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1337 CORE_ADDR low
, CORE_ADDR high
,
1338 const struct block
*block
,
1339 gdb_disassembly_flags flags
)
1342 if (!tui_is_window_visible (DISASSEM_WIN
))
1345 printf_filtered ("Dump of assembler code ");
1347 printf_filtered ("for function %s:\n", name
);
1348 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1351 printf_filtered ("from %s to %s:\n",
1352 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1354 /* Dump the specified range. */
1355 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1359 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1361 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1362 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1363 printf_filtered (_("Address range %s to %s:\n"),
1364 paddress (gdbarch
, range_low
),
1365 paddress (gdbarch
, range_high
));
1366 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1367 range_low
, range_high
);
1370 printf_filtered ("End of assembler dump.\n");
1375 tui_show_assembly (gdbarch
, low
);
1380 /* Subroutine of disassemble_command to simplify it.
1381 Print a disassembly of the current function according to FLAGS. */
1384 disassemble_current_function (gdb_disassembly_flags flags
)
1386 struct frame_info
*frame
;
1387 struct gdbarch
*gdbarch
;
1388 CORE_ADDR low
, high
, pc
;
1390 const struct block
*block
;
1392 frame
= get_selected_frame (_("No frame selected."));
1393 gdbarch
= get_frame_arch (frame
);
1394 pc
= get_frame_address_in_block (frame
);
1395 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1396 error (_("No function contains program counter for selected frame."));
1398 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1401 /* FIXME: cagney/2004-02-07: This should be an observer. */
1402 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1404 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1406 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1409 /* Dump a specified section of assembly code.
1413 - dump the assembly code for the function of the current pc
1414 disassemble [/mrs] addr
1415 - dump the assembly code for the function at ADDR
1416 disassemble [/mrs] low,high
1417 disassemble [/mrs] low,+length
1418 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1420 A /m modifier will include source code with the assembly in a
1421 "source centric" view. This view lists only the file of the first insn,
1422 even if other source files are involved (e.g., inlined functions), and
1423 the output is in source order, even with optimized code. This view is
1424 considered deprecated as it hasn't been useful in practice.
1426 A /r modifier will include raw instructions in hex with the assembly.
1428 A /s modifier will include source code with the assembly, like /m, with
1429 two important differences:
1430 1) The output is still in pc address order.
1431 2) File names and contents for all relevant source files are displayed. */
1434 disassemble_command (const char *arg
, int from_tty
)
1436 struct gdbarch
*gdbarch
= get_current_arch ();
1437 CORE_ADDR low
, high
;
1440 gdb_disassembly_flags flags
;
1442 const struct block
*block
= nullptr;
1453 error (_("Missing modifier."));
1455 while (*p
&& ! isspace (*p
))
1460 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1463 flags
|= DISASSEMBLY_RAW_INSN
;
1466 flags
|= DISASSEMBLY_SOURCE
;
1469 error (_("Invalid disassembly modifier."));
1473 p
= skip_spaces (p
);
1476 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1477 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1478 error (_("Cannot specify both /m and /s."));
1482 flags
|= DISASSEMBLY_OMIT_FNAME
;
1483 disassemble_current_function (flags
);
1487 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1493 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1494 error (_("No function contains specified address."));
1496 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1499 /* FIXME: cagney/2004-02-07: This should be an observer. */
1500 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1502 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1503 flags
|= DISASSEMBLY_OMIT_FNAME
;
1507 /* Two arguments. */
1510 p
= skip_spaces (p
);
1516 high
= parse_and_eval_address (p
);
1521 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1525 make_command (const char *arg
, int from_tty
)
1528 shell_escape ("make", from_tty
);
1531 std::string cmd
= std::string ("make ") + arg
;
1533 shell_escape (cmd
.c_str (), from_tty
);
1538 show_user (const char *args
, int from_tty
)
1540 struct cmd_list_element
*c
;
1544 const char *comname
= args
;
1546 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1547 if (!cli_user_command_p (c
))
1548 error (_("Not a user command."));
1549 show_user_1 (c
, "", args
, gdb_stdout
);
1553 for (c
= cmdlist
; c
; c
= c
->next
)
1555 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1556 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1561 /* Search through names of commands and documentations for a certain
1562 regular expression. */
1565 apropos_command (const char *arg
, int from_tty
)
1567 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1569 if (arg
== NULL
|| *arg
== '\0')
1570 error (_("REGEXP string is empty"));
1572 compiled_regex
pattern (arg
, REG_ICASE
,
1573 _("Error in regular expression"));
1575 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1578 /* Subroutine of alias_command to simplify it.
1579 Return the first N elements of ARGV flattened back to a string
1580 with a space separating each element.
1581 ARGV may not be NULL.
1582 This does not take care of quoting elements in case they contain spaces
1586 argv_to_string (char **argv
, int n
)
1591 gdb_assert (argv
!= NULL
);
1592 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1594 for (i
= 0; i
< n
; ++i
)
1604 /* Subroutine of alias_command to simplify it.
1605 Return true if COMMAND exists, unambiguously. Otherwise false. */
1608 valid_command_p (const char *command
)
1610 struct cmd_list_element
*c
;
1612 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1614 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1617 /* This is the slightly tricky part.
1618 lookup_cmd_1 will return a pointer to the last part of COMMAND
1619 to match, leaving COMMAND pointing at the remainder. */
1620 while (*command
== ' ' || *command
== '\t')
1622 return *command
== '\0';
1625 /* Called when "alias" was incorrectly used. */
1628 alias_usage_error (void)
1630 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1633 /* Make an alias of an existing command. */
1636 alias_command (const char *args
, int from_tty
)
1638 int i
, alias_argc
, command_argc
;
1639 int abbrev_flag
= 0;
1641 const char *alias
, *command
;
1643 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1644 alias_usage_error ();
1646 equals
= strchr (args
, '=');
1647 std::string
args2 (args
, equals
- args
);
1649 gdb_argv
built_alias_argv (args2
.c_str ());
1650 gdb_argv
command_argv (equals
+ 1);
1652 char **alias_argv
= built_alias_argv
.get ();
1653 while (alias_argv
[0] != NULL
)
1655 if (strcmp (alias_argv
[0], "-a") == 0)
1660 else if (strcmp (alias_argv
[0], "--") == 0)
1669 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1670 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1671 alias_usage_error ();
1673 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1675 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1678 error (_("Invalid command name: %s"), alias_argv
[i
]);
1680 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1684 alias_argc
= countargv (alias_argv
);
1685 command_argc
= command_argv
.count ();
1687 /* COMMAND must exist.
1688 Reconstruct the command to remove any extraneous spaces,
1689 for better error messages. */
1690 std::string
command_string (argv_to_string (command_argv
.get (),
1692 command
= command_string
.c_str ();
1693 if (! valid_command_p (command
))
1694 error (_("Invalid command to alias to: %s"), command
);
1696 /* ALIAS must not exist. */
1697 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1698 alias
= alias_string
.c_str ();
1699 if (valid_command_p (alias
))
1700 error (_("Alias already exists: %s"), alias
);
1702 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1703 Example: alias spe = set print elements
1705 Otherwise ALIAS and COMMAND must have the same number of words,
1706 and every word except the last must identify the same prefix command;
1707 and the last word of ALIAS is made an alias of the last word of COMMAND.
1708 Example: alias set print elms = set pr elem
1709 Note that unambiguous abbreviations are allowed. */
1711 if (alias_argc
== 1)
1713 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1714 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1719 const char *alias_prefix
, *command_prefix
;
1720 struct cmd_list_element
*c_alias
, *c_command
;
1722 if (alias_argc
!= command_argc
)
1723 error (_("Mismatched command length between ALIAS and COMMAND."));
1725 /* Create copies of ALIAS and COMMAND without the last word,
1726 and use that to verify the leading elements give the same
1728 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1730 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1732 alias_prefix
= alias_prefix_string
.c_str ();
1733 command_prefix
= command_prefix_string
.c_str ();
1735 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1736 /* We've already tried to look up COMMAND. */
1737 gdb_assert (c_command
!= NULL
1738 && c_command
!= (struct cmd_list_element
*) -1);
1739 gdb_assert (c_command
->prefixlist
!= NULL
);
1740 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1741 if (c_alias
!= c_command
)
1742 error (_("ALIAS and COMMAND prefixes do not match."));
1744 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1745 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1746 command_argv
[command_argc
- 1],
1747 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1751 /* Print the file / line number / symbol name of the location
1752 specified by SAL. */
1755 print_sal_location (const symtab_and_line
&sal
)
1757 scoped_restore_current_program_space restore_pspace
;
1758 set_current_program_space (sal
.pspace
);
1760 const char *sym_name
= NULL
;
1761 if (sal
.symbol
!= NULL
)
1762 sym_name
= SYMBOL_PRINT_NAME (sal
.symbol
);
1763 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1764 symtab_to_filename_for_display (sal
.symtab
),
1765 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1768 /* Print a list of files and line numbers which a user may choose from
1769 in order to list a function which was specified ambiguously (as
1770 with `list classname::overloadedfuncname', for example). The SALS
1771 array provides the filenames and line numbers. FORMAT is a
1772 printf-style format string used to tell the user what was
1776 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1777 const char *format
, ...)
1780 va_start (ap
, format
);
1781 vprintf_filtered (format
, ap
);
1784 for (const auto &sal
: sals
)
1785 print_sal_location (sal
);
1788 /* Comparison function for filter_sals. Returns a qsort-style
1792 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1794 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1795 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1803 else if (dirb
== NULL
)
1810 r
= filename_cmp (dira
, dirb
);
1815 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1819 if (sala
.line
< salb
.line
)
1821 return sala
.line
== salb
.line
? 0 : 1;
1824 /* Remove any SALs that do not match the current program space, or
1825 which appear to be "file:line" duplicates. */
1828 filter_sals (std::vector
<symtab_and_line
> &sals
)
1830 /* Remove SALs that do not match. */
1831 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1832 [&] (const symtab_and_line
&sal
)
1833 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1836 std::sort (sals
.begin (), from
,
1837 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1838 { return cmp_symtabs (sala
, salb
) < 0; });
1840 from
= std::unique (sals
.begin (), from
,
1841 [&] (const symtab_and_line
&sala
,
1842 const symtab_and_line
&salb
)
1843 { return cmp_symtabs (sala
, salb
) == 0; });
1845 sals
.erase (from
, sals
.end ());
1849 set_debug (const char *arg
, int from_tty
)
1851 printf_unfiltered (_("\"set debug\" must be followed by "
1852 "the name of a debug subcommand.\n"));
1853 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1857 show_debug (const char *args
, int from_tty
)
1859 cmd_show_list (showdebuglist
, from_tty
, "");
1863 init_cmd_lists (void)
1865 max_user_call_depth
= 1024;
1869 show_info_verbose (struct ui_file
*file
, int from_tty
,
1870 struct cmd_list_element
*c
,
1874 fprintf_filtered (file
,
1875 _("Verbose printing of informational messages is %s.\n"),
1878 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1882 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1883 struct cmd_list_element
*c
, const char *value
)
1885 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1890 show_remote_debug (struct ui_file
*file
, int from_tty
,
1891 struct cmd_list_element
*c
, const char *value
)
1893 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1898 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1899 struct cmd_list_element
*c
, const char *value
)
1901 fprintf_filtered (file
,
1902 _("Timeout limit to wait for target to respond is %s.\n"),
1907 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1908 struct cmd_list_element
*c
, const char *value
)
1910 fprintf_filtered (file
,
1911 _("The max call depth for user-defined commands is %s.\n"),
1916 _initialize_cli_cmds (void)
1918 struct cmd_list_element
*c
;
1920 /* Define the classes of commands.
1921 They will appear in the help list in alphabetical order. */
1923 add_cmd ("internals", class_maintenance
, _("\
1924 Maintenance commands.\n\
1925 Some gdb commands are provided just for use by gdb maintainers.\n\
1926 These commands are subject to frequent change, and may not be as\n\
1927 well documented as user commands."),
1929 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
1930 add_cmd ("aliases", class_alias
,
1931 _("Aliases of other commands."), &cmdlist
);
1932 add_cmd ("user-defined", class_user
, _("\
1933 User-defined commands.\n\
1934 The commands in this class are those defined by the user.\n\
1935 Use the \"define\" command to define a command."), &cmdlist
);
1936 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
1938 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
1939 add_cmd ("files", class_files
, _("Specifying and examining files."),
1941 add_cmd ("breakpoints", class_breakpoint
,
1942 _("Making program stop at certain points."), &cmdlist
);
1943 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
1944 add_cmd ("stack", class_stack
, _("\
1945 Examining the stack.\n\
1946 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1947 counting from zero for the innermost (currently executing) frame.\n\n\
1948 At any time gdb identifies one frame as the \"selected\" frame.\n\
1949 Variable lookups are done with respect to the selected frame.\n\
1950 When the program being debugged stops, gdb selects the innermost frame.\n\
1951 The commands below can be used to select other frames by number or address."),
1953 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
1955 /* Define general commands. */
1957 add_com ("pwd", class_files
, pwd_command
, _("\
1958 Print working directory.\n\
1959 This is used for your program as well."));
1961 c
= add_cmd ("cd", class_files
, cd_command
, _("\
1962 Set working directory to DIR for debugger.\n\
1963 The debugger's current working directory specifies where scripts and other\n\
1964 files that can be loaded by GDB are located.\n\
1965 In order to change the inferior's current working directory, the recommended\n\
1966 way is to use the \"set cwd\" command."), &cmdlist
);
1967 set_cmd_completer (c
, filename_completer
);
1969 add_com ("echo", class_support
, echo_command
, _("\
1970 Print a constant string. Give string as argument.\n\
1971 C escape sequences may be used in the argument.\n\
1972 No newline is added at the end of the argument;\n\
1973 use \"\\n\" if you want a newline to be printed.\n\
1974 Since leading and trailing whitespace are ignored in command arguments,\n\
1975 if you want to print some you must use \"\\\" before leading whitespace\n\
1976 to be printed or after trailing whitespace."));
1978 add_setshow_enum_cmd ("script-extension", class_support
,
1979 script_ext_enums
, &script_ext_mode
, _("\
1980 Set mode for script filename extension recognition."), _("\
1981 Show mode for script filename extension recognition."), _("\
1982 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1983 soft == evaluate script according to filename extension, fallback to GDB script"
1985 strict == evaluate script according to filename extension, error if not supported"
1988 show_script_ext_mode
,
1989 &setlist
, &showlist
);
1991 add_com ("quit", class_support
, quit_command
, _("\
1993 Usage: quit [EXPR]\n\
1994 The optional expression EXPR, if present, is evaluated and the result\n\
1995 used as GDB's exit code. The default is zero."));
1996 c
= add_com ("help", class_support
, help_command
,
1997 _("Print list of commands."));
1998 set_cmd_completer (c
, command_completer
);
1999 add_com_alias ("q", "quit", class_support
, 1);
2000 add_com_alias ("h", "help", class_support
, 1);
2002 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2003 Set verbosity."), _("\
2004 Show verbosity."), NULL
,
2007 &setlist
, &showlist
);
2009 add_prefix_cmd ("history", class_support
, set_history
,
2010 _("Generic command for setting command history parameters."),
2011 &sethistlist
, "set history ", 0, &setlist
);
2012 add_prefix_cmd ("history", class_support
, show_history
,
2013 _("Generic command for showing command history parameters."),
2014 &showhistlist
, "show history ", 0, &showlist
);
2016 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2017 Set history expansion on command input."), _("\
2018 Show history expansion on command input."), _("\
2019 Without an argument, history expansion is enabled."),
2021 show_history_expansion_p
,
2022 &sethistlist
, &showhistlist
);
2024 add_prefix_cmd ("info", class_info
, info_command
, _("\
2025 Generic command for showing things about the program being debugged."),
2026 &infolist
, "info ", 0, &cmdlist
);
2027 add_com_alias ("i", "info", class_info
, 1);
2028 add_com_alias ("inf", "info", class_info
, 1);
2030 add_com ("complete", class_obscure
, complete_command
,
2031 _("List the completions for the rest of the line as a command."));
2033 add_prefix_cmd ("show", class_info
, show_command
, _("\
2034 Generic command for showing things about the debugger."),
2035 &showlist
, "show ", 0, &cmdlist
);
2036 /* Another way to get at the same thing. */
2037 add_info ("set", show_command
, _("Show all GDB settings."));
2039 c
= add_com ("with", class_vars
, with_command
, _("\
2040 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2041 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2042 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2043 With no COMMAND, repeats the last executed command.\n\
2045 SETTING is any setting you can change with the \"set\" subcommands.\n\
2047 with language pascal -- print obj\n\
2048 with print elements unlimited -- print obj\n\
2050 You can change multiple settings using nested with, and use\n\
2051 abbreviations for commands and/or values. E.g.:\n\
2052 w la p -- w p el u -- p obj"));
2053 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2054 add_com_alias ("w", "with", class_vars
, 1);
2056 add_cmd ("commands", no_set_class
, show_commands
, _("\
2057 Show the history of commands you typed.\n\
2058 You can supply a command number to start with, or a `+' to start after\n\
2059 the previous command number shown."),
2062 add_cmd ("version", no_set_class
, show_version
,
2063 _("Show what version of GDB this is."), &showlist
);
2065 add_cmd ("configuration", no_set_class
, show_configuration
,
2066 _("Show how GDB was configured at build time."), &showlist
);
2068 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2069 Set debugging of remote protocol."), _("\
2070 Show debugging of remote protocol."), _("\
2071 When enabled, each packet sent or received with the remote target\n\
2075 &setdebuglist
, &showdebuglist
);
2077 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2078 &remote_timeout
, _("\
2079 Set timeout limit to wait for target to respond."), _("\
2080 Show timeout limit to wait for target to respond."), _("\
2081 This value is used to set the time limit for gdb to wait for a response\n\
2084 show_remote_timeout
,
2085 &setlist
, &showlist
);
2087 add_prefix_cmd ("debug", no_class
, set_debug
,
2088 _("Generic command for setting gdb debugging flags."),
2089 &setdebuglist
, "set debug ", 0, &setlist
);
2091 add_prefix_cmd ("debug", no_class
, show_debug
,
2092 _("Generic command for showing gdb debugging flags."),
2093 &showdebuglist
, "show debug ", 0, &showlist
);
2095 c
= add_com ("shell", class_support
, shell_command
, _("\
2096 Execute the rest of the line as a shell command.\n\
2097 With no arguments, run an inferior shell."));
2098 set_cmd_completer (c
, filename_completer
);
2100 add_com_alias ("!", "shell", class_support
, 0);
2102 c
= add_com ("edit", class_files
, edit_command
, _("\
2103 Edit specified file or function.\n\
2104 With no argument, edits file containing most recent line listed.\n\
2105 Editing targets can be specified in these ways:\n\
2106 FILE:LINENUM, to edit at that line in that file,\n\
2107 FUNCTION, to edit at the beginning of that function,\n\
2108 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2109 *ADDRESS, to edit at the line containing that address.\n\
2110 Uses EDITOR environment variable contents as editor (or ex as default)."));
2112 c
->completer
= location_completer
;
2114 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2115 Send the output of a gdb command to a shell command.\n\
2116 Usage: | [COMMAND] | SHELL_COMMAND\n\
2117 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2118 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2119 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2121 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2123 The -d option indicates to use the string DELIM to separate COMMAND\n\
2124 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2125 case COMMAND contains a | character.\n\
2127 With no COMMAND, repeat the last executed command\n\
2128 and send its output to SHELL_COMMAND."));
2129 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2130 add_com_alias ("|", "pipe", class_support
, 0);
2132 add_com ("list", class_files
, list_command
, _("\
2133 List specified function or line.\n\
2134 With no argument, lists ten more lines after or around previous listing.\n\
2135 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2136 One argument specifies a line, and ten lines are listed around that line.\n\
2137 Two arguments with comma between specify starting and ending lines to list.\n\
2138 Lines can be specified in these ways:\n\
2139 LINENUM, to list around that line in current file,\n\
2140 FILE:LINENUM, to list around that line in that file,\n\
2141 FUNCTION, to list around beginning of that function,\n\
2142 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2143 *ADDRESS, to list around the line containing that address.\n\
2144 With two args, if one is empty, it stands for ten lines away from\n\
2147 By default, when a single location is given, display ten lines.\n\
2148 This can be changed using \"set listsize\", and the current value\n\
2149 can be shown using \"show listsize\"."));
2151 add_com_alias ("l", "list", class_files
, 1);
2154 add_com_alias ("file", "list", class_files
, 1);
2156 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2157 Disassemble a specified section of memory.\n\
2158 Default is the function surrounding the pc of the selected frame.\n\
2160 With a /m modifier, source lines are included (if available).\n\
2161 This view is \"source centric\": the output is in source line order,\n\
2162 regardless of any optimization that is present. Only the main source file\n\
2163 is displayed, not those of, e.g., any inlined functions.\n\
2164 This modifier hasn't proved useful in practice and is deprecated\n\
2167 With a /s modifier, source lines are included (if available).\n\
2168 This differs from /m in two important respects:\n\
2169 - the output is still in pc address order, and\n\
2170 - file names and contents for all relevant source files are displayed.\n\
2172 With a /r modifier, raw instructions in hex are included.\n\
2174 With a single argument, the function surrounding that address is dumped.\n\
2175 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2176 in the form of \"start,end\", or \"start,+length\".\n\
2178 Note that the address is interpreted as an expression, not as a location\n\
2179 like in the \"break\" command.\n\
2180 So, for example, if you want to disassemble function bar in file foo.c\n\
2181 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2182 set_cmd_completer (c
, location_completer
);
2184 c
= add_com ("make", class_support
, make_command
, _("\
2185 Run the ``make'' program using the rest of the line as arguments."));
2186 set_cmd_completer (c
, filename_completer
);
2187 add_cmd ("user", no_class
, show_user
, _("\
2188 Show definitions of non-python/scheme user defined commands.\n\
2189 Argument is the name of the user defined command.\n\
2190 With no argument, show definitions of all user defined commands."), &showlist
);
2191 add_com ("apropos", class_support
, apropos_command
, _("\
2192 Search for commands matching a REGEXP.\n\
2193 Usage: apropos [-v] REGEXP\n\
2194 Flag -v indicates to produce a verbose output, showing full documentation\n\
2195 of the matching commands."));
2197 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2198 &max_user_call_depth
, _("\
2199 Set the max call depth for non-python/scheme user-defined commands."), _("\
2200 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2202 show_max_user_call_depth
,
2203 &setlist
, &showlist
);
2205 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2206 Set tracing of GDB CLI commands."), _("\
2207 Show state of GDB CLI command tracing."), _("\
2208 When 'on', each command is displayed as it is executed."),
2211 &setlist
, &showlist
);
2213 c
= add_com ("alias", class_support
, alias_command
, _("\
2214 Define a new command that is an alias of an existing command.\n\
2215 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2216 ALIAS is the name of the alias command to create.\n\
2217 COMMAND is the command being aliased to.\n\
2218 If \"-a\" is specified, the command is an abbreviation,\n\
2219 and will not appear in help command list output.\n\
2222 Make \"spe\" an alias of \"set print elements\":\n\
2223 alias spe = set print elements\n\
2224 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2225 alias -a set print elms = set print elements"));
2227 const char *source_help_text
= xstrprintf (_("\
2228 Read commands from a file named FILE.\n\
2230 Usage: source [-s] [-v] FILE\n\
2231 -s: search for the script in the source search path,\n\
2232 even if FILE contains directories.\n\
2233 -v: each command in FILE is echoed as it is executed.\n\
2235 Note that the file \"%s\" is read automatically in this way\n\
2236 when GDB is started."), GDBINIT
);
2237 c
= add_cmd ("source", class_support
, source_command
,
2238 source_help_text
, &cmdlist
);
2239 set_cmd_completer (c
, filename_completer
);