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 "common/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 "common/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-utils.h"
54 #include "extension.h"
55 #include "common/pathstuff.h"
58 #include "tui/tui.h" /* For tui_active et.al. */
65 /* Prototypes for local utility functions */
67 static void print_sal_location (const symtab_and_line
&sal
);
69 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
70 const char *format
, ...)
71 ATTRIBUTE_PRINTF (2, 3);
73 static void filter_sals (std::vector
<symtab_and_line
> &);
76 /* Limit the call depth of user-defined commands */
77 unsigned int max_user_call_depth
;
79 /* Define all cmd_list_elements. */
81 /* Chain containing all defined commands. */
83 struct cmd_list_element
*cmdlist
;
85 /* Chain containing all defined info subcommands. */
87 struct cmd_list_element
*infolist
;
89 /* Chain containing all defined enable subcommands. */
91 struct cmd_list_element
*enablelist
;
93 /* Chain containing all defined disable subcommands. */
95 struct cmd_list_element
*disablelist
;
97 /* Chain containing all defined stop subcommands. */
99 struct cmd_list_element
*stoplist
;
101 /* Chain containing all defined delete subcommands. */
103 struct cmd_list_element
*deletelist
;
105 /* Chain containing all defined detach subcommands. */
107 struct cmd_list_element
*detachlist
;
109 /* Chain containing all defined kill subcommands. */
111 struct cmd_list_element
*killlist
;
113 /* Chain containing all defined set subcommands */
115 struct cmd_list_element
*setlist
;
117 /* Chain containing all defined unset subcommands */
119 struct cmd_list_element
*unsetlist
;
121 /* Chain containing all defined show subcommands. */
123 struct cmd_list_element
*showlist
;
125 /* Chain containing all defined \"set history\". */
127 struct cmd_list_element
*sethistlist
;
129 /* Chain containing all defined \"show history\". */
131 struct cmd_list_element
*showhistlist
;
133 /* Chain containing all defined \"unset history\". */
135 struct cmd_list_element
*unsethistlist
;
137 /* Chain containing all defined maintenance subcommands. */
139 struct cmd_list_element
*maintenancelist
;
141 /* Chain containing all defined "maintenance info" subcommands. */
143 struct cmd_list_element
*maintenanceinfolist
;
145 /* Chain containing all defined "maintenance print" subcommands. */
147 struct cmd_list_element
*maintenanceprintlist
;
149 /* Chain containing all defined "maintenance check" subcommands. */
151 struct cmd_list_element
*maintenancechecklist
;
153 struct cmd_list_element
*setprintlist
;
155 struct cmd_list_element
*showprintlist
;
157 struct cmd_list_element
*setdebuglist
;
159 struct cmd_list_element
*showdebuglist
;
161 struct cmd_list_element
*setchecklist
;
163 struct cmd_list_element
*showchecklist
;
165 /* Command tracing state. */
167 int source_verbose
= 0;
168 int trace_commands
= 0;
170 /* 'script-extension' option support. */
172 static const char script_ext_off
[] = "off";
173 static const char script_ext_soft
[] = "soft";
174 static const char script_ext_strict
[] = "strict";
176 static const char *const script_ext_enums
[] = {
183 static const char *script_ext_mode
= script_ext_soft
;
185 /* Utility used everywhere when at least one argument is needed and
189 error_no_arg (const char *why
)
191 error (_("Argument required (%s)."), why
);
194 /* The "info" command is defined as a prefix, with allow_unknown = 0.
195 Therefore, its own definition is called only for "info" with no
199 info_command (const char *arg
, int from_tty
)
201 printf_unfiltered (_("\"info\" must be followed by "
202 "the name of an info command.\n"));
203 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
206 /* The "show" command with no arguments shows all the settings. */
209 show_command (const char *arg
, int from_tty
)
211 cmd_show_list (showlist
, from_tty
, "");
214 /* See cli/cli-cmds.h. */
217 with_command_1 (const char *set_cmd_prefix
,
218 cmd_list_element
*setlist
, const char *args
, int from_tty
)
220 const char *delim
= strstr (args
, "--");
221 const char *nested_cmd
= nullptr;
224 error (_("Missing setting before '--' delimiter"));
226 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
227 nested_cmd
= repeat_previous ();
229 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
230 /*allow_unknown=*/ 0,
231 /*ignore_help_classes=*/ 1);
232 gdb_assert (set_cmd
!= nullptr);
234 if (set_cmd
->var
== nullptr)
235 error (_("Cannot use this setting with the \"with\" command"));
237 std::string temp_value
238 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
240 if (nested_cmd
== nullptr)
241 nested_cmd
= skip_spaces (delim
+ 2);
243 std::string org_value
= get_setshow_command_value_string (set_cmd
);
245 /* Tweak the setting to the new temporary value. */
246 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
250 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
252 /* Execute the nested command. */
253 execute_command (nested_cmd
, from_tty
);
255 catch (const gdb_exception
&ex
)
257 /* Restore the setting and rethrow. If restoring the setting
258 throws, swallow the new exception and warn. There's nothing
259 else we can reasonably do. */
262 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
264 catch (const gdb_exception
&ex2
)
266 warning (_("Couldn't restore setting: %s"), ex2
.what ());
272 /* Restore the setting. */
273 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
276 /* See cli/cli-cmds.h. */
279 with_command_completer_1 (const char *set_cmd_prefix
,
280 completion_tracker
&tracker
,
283 tracker
.set_use_custom_word_point (true);
285 const char *delim
= strstr (text
, "--");
287 /* If we're still not past the "--" delimiter, complete the "with"
288 command as if it was a "set" command. */
291 || !isspace (delim
[-1])
292 || !(isspace (delim
[2]) || delim
[2] == '\0'))
294 std::string new_text
= std::string (set_cmd_prefix
) + text
;
295 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
296 complete_nested_command_line (tracker
, new_text
.c_str ());
300 /* We're past the "--" delimiter. Complete on the sub command. */
301 const char *nested_cmd
= skip_spaces (delim
+ 2);
302 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
303 complete_nested_command_line (tracker
, nested_cmd
);
306 /* The "with" command. */
309 with_command (const char *args
, int from_tty
)
311 with_command_1 ("set ", setlist
, args
, from_tty
);
314 /* "with" command completer. */
317 with_command_completer (struct cmd_list_element
*ignore
,
318 completion_tracker
&tracker
,
319 const char *text
, const char * /*word*/)
321 with_command_completer_1 ("set ", tracker
, text
);
325 /* Provide documentation on command or list given by COMMAND. FROM_TTY
329 help_command (const char *command
, int from_tty
)
331 help_cmd (command
, gdb_stdout
);
335 /* Note: The "complete" command is used by Emacs to implement completion.
336 [Is that why this function writes output with *_unfiltered?] */
339 complete_command (const char *arg
, int from_tty
)
343 if (max_completions
== 0)
345 /* Only print this for non-mi frontends. An MI frontend may not
346 be able to handle this. */
347 if (!current_uiout
->is_mi_like_p ())
349 printf_unfiltered (_("max-completions is zero,"
350 " completion is disabled.\n"));
358 int quote_char
= '\0';
361 completion_result result
= complete (arg
, &word
, "e_char
);
363 if (result
.number_matches
!= 0)
365 std::string
arg_prefix (arg
, word
- arg
);
367 if (result
.number_matches
== 1)
368 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
371 result
.sort_match_list ();
373 for (size_t i
= 0; i
< result
.number_matches
; i
++)
375 printf_unfiltered ("%s%s",
377 result
.match_list
[i
+ 1]);
379 printf_unfiltered ("%c", quote_char
);
380 printf_unfiltered ("\n");
384 if (result
.number_matches
== max_completions
)
386 /* ARG_PREFIX and WORD are included in the output so that emacs
387 will include the message in the output. */
388 printf_unfiltered (_("%s%s %s\n"),
389 arg_prefix
.c_str (), word
,
390 get_max_completions_reached_message ());
396 is_complete_command (struct cmd_list_element
*c
)
398 return cmd_cfunc_eq (c
, complete_command
);
402 show_version (const char *args
, int from_tty
)
404 print_gdb_version (gdb_stdout
, true);
405 printf_filtered ("\n");
409 show_configuration (const char *args
, int from_tty
)
411 print_gdb_configuration (gdb_stdout
);
414 /* Handle the quit command. */
417 quit_command (const char *args
, int from_tty
)
421 /* An optional expression may be used to cause gdb to terminate with
422 the value of that expression. */
425 struct value
*val
= parse_and_eval (args
);
427 exit_code
= (int) value_as_long (val
);
430 if (!quit_confirm ())
431 error (_("Not confirmed."));
433 query_if_trace_running (from_tty
);
435 quit_force (args
? &exit_code
: NULL
, from_tty
);
439 pwd_command (const char *args
, int from_tty
)
442 error (_("The \"pwd\" command does not take an argument: %s"), args
);
444 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
447 error (_("Error finding name of working directory: %s"),
448 safe_strerror (errno
));
450 if (strcmp (cwd
.get (), current_directory
) != 0)
451 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
452 current_directory
, cwd
.get ());
454 printf_unfiltered (_("Working directory %s.\n"), current_directory
);
458 cd_command (const char *dir
, int from_tty
)
461 /* Found something other than leading repetitions of "/..". */
465 /* If the new directory is absolute, repeat is a no-op; if relative,
466 repeat might be useful but is more likely to be a mistake. */
469 gdb::unique_xmalloc_ptr
<char> dir_holder
470 (tilde_expand (dir
!= NULL
? dir
: "~"));
471 dir
= dir_holder
.get ();
474 perror_with_name (dir
);
476 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
477 /* There's too much mess with DOSish names like "d:", "d:.",
478 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
479 simply get the canonicalized name of the current directory. */
480 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
485 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
487 /* Remove the trailing slash unless this is a root directory
488 (including a drive letter on non-Unix systems). */
489 if (!(len
== 1) /* "/" */
490 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
491 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
497 dir_holder
.reset (savestring (dir
, len
));
498 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
500 xfree (current_directory
);
501 current_directory
= dir_holder
.release ();
505 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
506 current_directory
= concat (current_directory
, dir_holder
.get (),
509 current_directory
= concat (current_directory
, SLASH_STRING
,
510 dir_holder
.get (), (char *) NULL
);
513 /* Now simplify any occurrences of `.' and `..' in the pathname. */
516 for (p
= current_directory
; *p
;)
518 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
519 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
520 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
521 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
522 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
526 /* Search backwards for the directory just before the "/.."
527 and obliterate it and the "/..". */
530 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
533 if (q
== current_directory
)
534 /* current_directory is
535 a relative pathname ("can't happen"--leave it alone). */
539 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
544 /* We are dealing with leading repetitions of "/..", for
545 example "/../..", which is the Mach super-root. */
555 forget_cached_source_info ();
558 pwd_command ((char *) 0, 1);
561 /* Show the current value of the 'script-extension' option. */
564 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
565 struct cmd_list_element
*c
, const char *value
)
567 fprintf_filtered (file
,
568 _("Script filename extension recognition is \"%s\".\n"),
572 /* Try to open SCRIPT_FILE.
573 If successful, the full path name is stored in *FULL_PATHP,
574 and the stream is returned.
575 If not successful, return NULL; errno is set for the last file
578 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
579 search for it in the source search path. */
581 gdb::optional
<open_script
>
582 find_and_open_script (const char *script_file
, int search_path
)
585 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
586 gdb::optional
<open_script
> opened
;
588 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
591 search_flags
|= OPF_SEARCH_IN_PATH
;
593 /* Search for and open 'file' on the search path used for source
594 files. Put the full location in *FULL_PATHP. */
595 gdb::unique_xmalloc_ptr
<char> full_path
;
596 fd
= openp (source_path
, search_flags
,
597 file
.get (), O_RDONLY
, &full_path
);
602 FILE *result
= fdopen (fd
, FOPEN_RT
);
605 int save_errno
= errno
;
611 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
616 /* Load script FILE, which has already been opened as STREAM.
617 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
618 This is provided as FILE may have been found via the source search path.
619 An important thing to note here is that FILE may be a symlink to a file
620 with a different or non-existing suffix, and thus one cannot infer the
621 extension language from FILE_TO_OPEN. */
624 source_script_from_stream (FILE *stream
, const char *file
,
625 const char *file_to_open
)
627 if (script_ext_mode
!= script_ext_off
)
629 const struct extension_language_defn
*extlang
630 = get_ext_lang_of_file (file
);
634 if (ext_lang_present_p (extlang
))
636 script_sourcer_func
*sourcer
637 = ext_lang_script_sourcer (extlang
);
639 gdb_assert (sourcer
!= NULL
);
640 sourcer (extlang
, stream
, file_to_open
);
643 else if (script_ext_mode
== script_ext_soft
)
645 /* Assume the file is a gdb script.
646 This is handled below. */
649 throw_ext_lang_unsupported (extlang
);
653 script_from_file (stream
, file
);
656 /* Worker to perform the "source" command.
658 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
659 search for it in the source search path. */
662 source_script_with_search (const char *file
, int from_tty
, int search_path
)
665 if (file
== NULL
|| *file
== 0)
666 error (_("source command requires file name of file to source."));
668 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
671 /* The script wasn't found, or was otherwise inaccessible.
672 If the source command was invoked interactively, throw an
673 error. Otherwise (e.g. if it was invoked by a script),
674 just emit a warning, rather than cause an error. */
676 perror_with_name (file
);
679 perror_warning_with_name (file
);
684 /* The python support reopens the file, so we need to pass full_path here
685 in case the file was found on the search path. It's useful to do this
686 anyway so that error messages show the actual file used. But only do
687 this if we (may have) used search_path, as printing the full path in
688 errors for the non-search case can be more noise than signal. */
689 source_script_from_stream (opened
->stream
.get (), file
,
690 search_path
? opened
->full_path
.get () : file
);
693 /* Wrapper around source_script_with_search to export it to main.c
694 for use in loading .gdbinit scripts. */
697 source_script (const char *file
, int from_tty
)
699 source_script_with_search (file
, from_tty
, 0);
703 source_command (const char *args
, int from_tty
)
705 const char *file
= args
;
708 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
710 /* -v causes the source command to run in verbose mode.
711 -s causes the file to be searched in the source search path,
712 even if the file name contains a '/'.
713 We still have to be able to handle filenames with spaces in a
714 backward compatible way, so buildargv is not appropriate. */
718 while (args
[0] != '\0')
720 /* Make sure leading white space does not break the
722 args
= skip_spaces (args
);
727 if (args
[1] == 'v' && isspace (args
[2]))
731 /* Skip passed -v. */
734 else if (args
[1] == 's' && isspace (args
[2]))
738 /* Skip passed -s. */
745 file
= skip_spaces (args
);
748 source_script_with_search (file
, from_tty
, search_path
);
753 echo_command (const char *text
, int from_tty
)
755 const char *p
= text
;
759 while ((c
= *p
++) != '\0')
763 /* \ at end of argument is used after spaces
764 so they won't be lost. */
768 c
= parse_escape (get_current_arch (), &p
);
770 printf_filtered ("%c", c
);
773 printf_filtered ("%c", c
);
776 reset_terminal_style (gdb_stdout
);
778 /* Force this output to appear now. */
780 gdb_flush (gdb_stdout
);
783 /* Sets the last launched shell command convenience variables based on
787 exit_status_set_internal_vars (int exit_status
)
789 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
790 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
792 clear_internalvar (var_code
);
793 clear_internalvar (var_signal
);
794 if (WIFEXITED (exit_status
))
795 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
796 else if (WIFSIGNALED (exit_status
))
797 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
799 warning (_("unexpected shell command exit status %d"), exit_status
);
803 shell_escape (const char *arg
, int from_tty
)
805 #if defined(CANT_FORK) || \
806 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
807 /* If ARG is NULL, they want an inferior shell, but `system' just
808 reports if the shell is available when passed a NULL arg. */
809 int rc
= system (arg
? arg
: "");
812 arg
= "inferior shell";
815 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
816 safe_strerror (errno
));
818 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
820 /* Make sure to return to the directory GDB thinks it is, in case
821 the shell command we just ran changed it. */
822 chdir (current_directory
);
823 exit_status_set_internal_vars (rc
);
825 #else /* Can fork. */
828 if ((pid
= vfork ()) == 0)
830 const char *p
, *user_shell
= get_shell ();
834 /* Get the name of the shell for arg0. */
835 p
= lbasename (user_shell
);
838 execl (user_shell
, p
, (char *) 0);
840 execl (user_shell
, p
, "-c", arg
, (char *) 0);
842 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
843 safe_strerror (errno
));
848 waitpid (pid
, &status
, 0);
850 error (_("Fork failed"));
851 exit_status_set_internal_vars (status
);
852 #endif /* Can fork. */
855 /* Implementation of the "shell" command. */
858 shell_command (const char *arg
, int from_tty
)
860 shell_escape (arg
, from_tty
);
864 edit_command (const char *arg
, int from_tty
)
866 struct symtab_and_line sal
;
872 /* Pull in the current default source line if necessary. */
875 set_default_source_symtab_and_line ();
876 sal
= get_current_source_symtab_and_line ();
879 /* Bare "edit" edits file with present line. */
884 error (_("No default source file yet."));
885 sal
.line
+= get_lines_to_list () / 2;
891 /* Now should only be one argument -- decode it in SAL. */
893 event_location_up location
= string_to_event_location (&arg1
,
895 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
896 DECODE_LINE_LIST_MODE
,
905 if (sals
.size () > 1)
907 ambiguous_line_spec (sals
,
908 _("Specified line is ambiguous:\n"));
915 error (_("Junk at end of line specification."));
917 /* If line was specified by address, first print exactly which
918 line, and which file. In this case, sal.symtab == 0 means
919 address is outside of all known source files, not that user
920 failed to give a filename. */
923 struct gdbarch
*gdbarch
;
926 error (_("No source file for address %s."),
927 paddress (get_current_arch (), sal
.pc
));
929 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
930 sym
= find_pc_function (sal
.pc
);
932 printf_filtered ("%s is in %s (%s:%d).\n",
933 paddress (gdbarch
, sal
.pc
),
934 SYMBOL_PRINT_NAME (sym
),
935 symtab_to_filename_for_display (sal
.symtab
),
938 printf_filtered ("%s is at %s:%d.\n",
939 paddress (gdbarch
, sal
.pc
),
940 symtab_to_filename_for_display (sal
.symtab
),
944 /* If what was given does not imply a symtab, it must be an
945 undebuggable symbol which means no source code. */
948 error (_("No line number known for %s."), arg
);
951 if ((editor
= getenv ("EDITOR")) == NULL
)
954 fn
= symtab_to_fullname (sal
.symtab
);
956 /* Quote the file name, in case it has whitespace or other special
958 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
959 shell_escape (p
, from_tty
);
963 /* Implementation of the "pipe" command. */
966 pipe_command (const char *arg
, int from_tty
)
968 std::string
delim ("|");
970 if (arg
!= nullptr && check_for_argument (&arg
, "-d", 2))
972 delim
= extract_arg (&arg
);
974 error (_("Missing delimiter DELIM after -d"));
977 const char *command
= arg
;
978 if (command
== nullptr)
979 error (_("Missing COMMAND"));
981 arg
= strstr (arg
, delim
.c_str ());
984 error (_("Missing delimiter before SHELL_COMMAND"));
986 std::string
gdb_cmd (command
, arg
- command
);
988 arg
+= delim
.length (); /* Skip the delimiter. */
990 if (gdb_cmd
.empty ())
991 gdb_cmd
= repeat_previous ();
993 const char *shell_command
= skip_spaces (arg
);
994 if (*shell_command
== '\0')
995 error (_("Missing SHELL_COMMAND"));
997 FILE *to_shell_command
= popen (shell_command
, "w");
999 if (to_shell_command
== nullptr)
1000 error (_("Error launching \"%s\""), shell_command
);
1004 stdio_file
pipe_file (to_shell_command
);
1006 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1010 pclose (to_shell_command
);
1014 int exit_status
= pclose (to_shell_command
);
1016 if (exit_status
< 0)
1017 error (_("shell command \"%s\" failed: %s"), shell_command
,
1018 safe_strerror (errno
));
1019 exit_status_set_internal_vars (exit_status
);
1023 list_command (const char *arg
, int from_tty
)
1030 int linenum_beg
= 0;
1033 /* Pull in the current default source line if necessary. */
1034 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1036 set_default_source_symtab_and_line ();
1037 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1039 /* If this is the first "list" since we've set the current
1040 source line, center the listing around that line. */
1041 if (get_first_line_listed () == 0)
1045 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1047 /* A small special case --- if listing backwards, and we
1048 should list only one line, list the preceding line,
1049 instead of the exact line we've just shown after e.g.,
1050 stopping for a breakpoint. */
1051 if (arg
!= NULL
&& arg
[0] == '-'
1052 && get_lines_to_list () == 1 && first
> 1)
1055 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1058 /* "l" or "l +" lists next ten lines. */
1059 else if (arg
== NULL
|| arg
[0] == '+')
1060 print_source_lines (cursal
.symtab
,
1061 source_lines_range (cursal
.line
), 0);
1063 /* "l -" lists previous ten lines, the ones before the ten just
1065 else if (arg
[0] == '-')
1067 if (get_first_line_listed () == 1)
1068 error (_("Already at the start of %s."),
1069 symtab_to_filename_for_display (cursal
.symtab
));
1070 source_lines_range
range (get_first_line_listed (),
1071 source_lines_range::BACKWARD
);
1072 print_source_lines (cursal
.symtab
, range
, 0);
1078 /* Now if there is only one argument, decode it in SAL
1080 If there are two arguments, decode them in SAL and SAL_END
1081 and clear NO_END; however, if one of the arguments is blank,
1082 set DUMMY_BEG or DUMMY_END to record that fact. */
1084 if (!have_full_symbols () && !have_partial_symbols ())
1085 error (_("No symbol table is loaded. Use the \"file\" command."));
1087 std::vector
<symtab_and_line
> sals
;
1088 symtab_and_line sal
, sal_end
;
1095 event_location_up location
= string_to_event_location (&arg1
,
1097 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1109 /* Record whether the BEG arg is all digits. */
1111 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1112 linenum_beg
= (p
== arg1
);
1114 /* Save the range of the first argument, in case we need to let the
1115 user know it was ambiguous. */
1116 const char *beg
= arg
;
1117 size_t beg_len
= arg1
- beg
;
1119 while (*arg1
== ' ' || *arg1
== '\t')
1124 if (sals
.size () > 1)
1126 ambiguous_line_spec (sals
,
1127 _("Specified first line '%.*s' is ambiguous:\n"),
1128 (int) beg_len
, beg
);
1132 while (*arg1
== ' ' || *arg1
== '\t')
1138 /* Save the last argument, in case we need to let the user
1139 know it was ambiguous. */
1140 const char *end_arg
= arg1
;
1142 event_location_up location
1143 = string_to_event_location (&arg1
, current_language
);
1145 std::vector
<symtab_and_line
> sals_end
1147 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1149 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1150 NULL
, sal
.symtab
, sal
.line
));
1152 filter_sals (sals_end
);
1153 if (sals_end
.empty ())
1155 if (sals_end
.size () > 1)
1157 ambiguous_line_spec (sals_end
,
1158 _("Specified last line '%s' is ambiguous:\n"),
1162 sal_end
= sals_end
[0];
1167 error (_("Junk at end of line specification."));
1169 if (!no_end
&& !dummy_beg
&& !dummy_end
1170 && sal
.symtab
!= sal_end
.symtab
)
1171 error (_("Specified first and last lines are in different files."));
1172 if (dummy_beg
&& dummy_end
)
1173 error (_("Two empty args do not say what lines to list."));
1175 /* If line was specified by address,
1176 first print exactly which line, and which file.
1178 In this case, sal.symtab == 0 means address is outside of all
1179 known source files, not that user failed to give a filename. */
1182 struct gdbarch
*gdbarch
;
1184 if (sal
.symtab
== 0)
1185 error (_("No source file for address %s."),
1186 paddress (get_current_arch (), sal
.pc
));
1188 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1189 sym
= find_pc_function (sal
.pc
);
1191 printf_filtered ("%s is in %s (%s:%d).\n",
1192 paddress (gdbarch
, sal
.pc
),
1193 SYMBOL_PRINT_NAME (sym
),
1194 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1196 printf_filtered ("%s is at %s:%d.\n",
1197 paddress (gdbarch
, sal
.pc
),
1198 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1201 /* If line was not specified by just a line number, and it does not
1202 imply a symtab, it must be an undebuggable symbol which means no
1205 if (!linenum_beg
&& sal
.symtab
== 0)
1206 error (_("No line number known for %s."), arg
);
1208 /* If this command is repeated with RET,
1209 turn it into the no-arg variant. */
1212 set_repeat_arguments ("");
1214 if (dummy_beg
&& sal_end
.symtab
== 0)
1215 error (_("No default source file yet. Do \"help list\"."));
1218 source_lines_range
range (sal_end
.line
+ 1,
1219 source_lines_range::BACKWARD
);
1220 print_source_lines (sal_end
.symtab
, range
, 0);
1222 else if (sal
.symtab
== 0)
1223 error (_("No default source file yet. Do \"help list\"."));
1226 for (int i
= 0; i
< sals
.size (); i
++)
1229 int first_line
= sal
.line
- get_lines_to_list () / 2;
1232 if (sals
.size () > 1)
1233 print_sal_location (sal
);
1234 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1238 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1240 print_source_lines (sal
.symtab
,
1241 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1245 /* Subroutine of disassemble_command to simplify it.
1246 Perform the disassembly.
1247 NAME is the name of the function if known, or NULL.
1248 [LOW,HIGH) are the range of addresses to disassemble.
1249 BLOCK is the block to disassemble; it needs to be provided
1250 when non-contiguous blocks are disassembled; otherwise
1252 MIXED is non-zero to print source with the assembler. */
1255 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1256 CORE_ADDR low
, CORE_ADDR high
,
1257 const struct block
*block
,
1258 gdb_disassembly_flags flags
)
1261 if (!tui_is_window_visible (DISASSEM_WIN
))
1264 printf_filtered ("Dump of assembler code ");
1266 printf_filtered ("for function %s:\n", name
);
1267 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1270 printf_filtered ("from %s to %s:\n",
1271 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1273 /* Dump the specified range. */
1274 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1278 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1280 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1281 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1282 printf_filtered (_("Address range %s to %s:\n"),
1283 paddress (gdbarch
, range_low
),
1284 paddress (gdbarch
, range_high
));
1285 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1286 range_low
, range_high
);
1289 printf_filtered ("End of assembler dump.\n");
1294 tui_show_assembly (gdbarch
, low
);
1299 /* Subroutine of disassemble_command to simplify it.
1300 Print a disassembly of the current function according to FLAGS. */
1303 disassemble_current_function (gdb_disassembly_flags flags
)
1305 struct frame_info
*frame
;
1306 struct gdbarch
*gdbarch
;
1307 CORE_ADDR low
, high
, pc
;
1309 const struct block
*block
;
1311 frame
= get_selected_frame (_("No frame selected."));
1312 gdbarch
= get_frame_arch (frame
);
1313 pc
= get_frame_address_in_block (frame
);
1314 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1315 error (_("No function contains program counter for selected frame."));
1317 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1320 /* FIXME: cagney/2004-02-07: This should be an observer. */
1321 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1323 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1325 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1328 /* Dump a specified section of assembly code.
1332 - dump the assembly code for the function of the current pc
1333 disassemble [/mrs] addr
1334 - dump the assembly code for the function at ADDR
1335 disassemble [/mrs] low,high
1336 disassemble [/mrs] low,+length
1337 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1339 A /m modifier will include source code with the assembly in a
1340 "source centric" view. This view lists only the file of the first insn,
1341 even if other source files are involved (e.g., inlined functions), and
1342 the output is in source order, even with optimized code. This view is
1343 considered deprecated as it hasn't been useful in practice.
1345 A /r modifier will include raw instructions in hex with the assembly.
1347 A /s modifier will include source code with the assembly, like /m, with
1348 two important differences:
1349 1) The output is still in pc address order.
1350 2) File names and contents for all relevant source files are displayed. */
1353 disassemble_command (const char *arg
, int from_tty
)
1355 struct gdbarch
*gdbarch
= get_current_arch ();
1356 CORE_ADDR low
, high
;
1359 gdb_disassembly_flags flags
;
1361 const struct block
*block
= nullptr;
1372 error (_("Missing modifier."));
1374 while (*p
&& ! isspace (*p
))
1379 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1382 flags
|= DISASSEMBLY_RAW_INSN
;
1385 flags
|= DISASSEMBLY_SOURCE
;
1388 error (_("Invalid disassembly modifier."));
1392 p
= skip_spaces (p
);
1395 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1396 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1397 error (_("Cannot specify both /m and /s."));
1401 flags
|= DISASSEMBLY_OMIT_FNAME
;
1402 disassemble_current_function (flags
);
1406 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1412 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1413 error (_("No function contains specified address."));
1415 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1418 /* FIXME: cagney/2004-02-07: This should be an observer. */
1419 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1421 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1422 flags
|= DISASSEMBLY_OMIT_FNAME
;
1426 /* Two arguments. */
1429 p
= skip_spaces (p
);
1435 high
= parse_and_eval_address (p
);
1440 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1444 make_command (const char *arg
, int from_tty
)
1447 shell_escape ("make", from_tty
);
1450 std::string cmd
= std::string ("make ") + arg
;
1452 shell_escape (cmd
.c_str (), from_tty
);
1457 show_user (const char *args
, int from_tty
)
1459 struct cmd_list_element
*c
;
1460 extern struct cmd_list_element
*cmdlist
;
1464 const char *comname
= args
;
1466 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1467 if (!cli_user_command_p (c
))
1468 error (_("Not a user command."));
1469 show_user_1 (c
, "", args
, gdb_stdout
);
1473 for (c
= cmdlist
; c
; c
= c
->next
)
1475 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1476 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1481 /* Search through names of commands and documentations for a certain
1482 regular expression. */
1485 apropos_command (const char *arg
, int from_tty
)
1487 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1489 if (arg
== NULL
|| *arg
== '\0')
1490 error (_("REGEXP string is empty"));
1492 compiled_regex
pattern (arg
, REG_ICASE
,
1493 _("Error in regular expression"));
1495 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1498 /* Subroutine of alias_command to simplify it.
1499 Return the first N elements of ARGV flattened back to a string
1500 with a space separating each element.
1501 ARGV may not be NULL.
1502 This does not take care of quoting elements in case they contain spaces
1506 argv_to_string (char **argv
, int n
)
1511 gdb_assert (argv
!= NULL
);
1512 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1514 for (i
= 0; i
< n
; ++i
)
1524 /* Subroutine of alias_command to simplify it.
1525 Return true if COMMAND exists, unambiguously. Otherwise false. */
1528 valid_command_p (const char *command
)
1530 struct cmd_list_element
*c
;
1532 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1534 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1537 /* This is the slightly tricky part.
1538 lookup_cmd_1 will return a pointer to the last part of COMMAND
1539 to match, leaving COMMAND pointing at the remainder. */
1540 while (*command
== ' ' || *command
== '\t')
1542 return *command
== '\0';
1545 /* Called when "alias" was incorrectly used. */
1548 alias_usage_error (void)
1550 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1553 /* Make an alias of an existing command. */
1556 alias_command (const char *args
, int from_tty
)
1558 int i
, alias_argc
, command_argc
;
1559 int abbrev_flag
= 0;
1561 const char *alias
, *command
;
1563 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1564 alias_usage_error ();
1566 equals
= strchr (args
, '=');
1567 std::string
args2 (args
, equals
- args
);
1569 gdb_argv
built_alias_argv (args2
.c_str ());
1570 gdb_argv
command_argv (equals
+ 1);
1572 char **alias_argv
= built_alias_argv
.get ();
1573 while (alias_argv
[0] != NULL
)
1575 if (strcmp (alias_argv
[0], "-a") == 0)
1580 else if (strcmp (alias_argv
[0], "--") == 0)
1589 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1590 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1591 alias_usage_error ();
1593 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1595 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1598 error (_("Invalid command name: %s"), alias_argv
[i
]);
1600 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1604 alias_argc
= countargv (alias_argv
);
1605 command_argc
= command_argv
.count ();
1607 /* COMMAND must exist.
1608 Reconstruct the command to remove any extraneous spaces,
1609 for better error messages. */
1610 std::string
command_string (argv_to_string (command_argv
.get (),
1612 command
= command_string
.c_str ();
1613 if (! valid_command_p (command
))
1614 error (_("Invalid command to alias to: %s"), command
);
1616 /* ALIAS must not exist. */
1617 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1618 alias
= alias_string
.c_str ();
1619 if (valid_command_p (alias
))
1620 error (_("Alias already exists: %s"), alias
);
1622 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1623 Example: alias spe = set print elements
1625 Otherwise ALIAS and COMMAND must have the same number of words,
1626 and every word except the last must identify the same prefix command;
1627 and the last word of ALIAS is made an alias of the last word of COMMAND.
1628 Example: alias set print elms = set pr elem
1629 Note that unambiguous abbreviations are allowed. */
1631 if (alias_argc
== 1)
1633 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1634 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1639 const char *alias_prefix
, *command_prefix
;
1640 struct cmd_list_element
*c_alias
, *c_command
;
1642 if (alias_argc
!= command_argc
)
1643 error (_("Mismatched command length between ALIAS and COMMAND."));
1645 /* Create copies of ALIAS and COMMAND without the last word,
1646 and use that to verify the leading elements give the same
1648 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1650 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1652 alias_prefix
= alias_prefix_string
.c_str ();
1653 command_prefix
= command_prefix_string
.c_str ();
1655 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1656 /* We've already tried to look up COMMAND. */
1657 gdb_assert (c_command
!= NULL
1658 && c_command
!= (struct cmd_list_element
*) -1);
1659 gdb_assert (c_command
->prefixlist
!= NULL
);
1660 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1661 if (c_alias
!= c_command
)
1662 error (_("ALIAS and COMMAND prefixes do not match."));
1664 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1665 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1666 command_argv
[command_argc
- 1],
1667 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1671 /* Print the file / line number / symbol name of the location
1672 specified by SAL. */
1675 print_sal_location (const symtab_and_line
&sal
)
1677 scoped_restore_current_program_space restore_pspace
;
1678 set_current_program_space (sal
.pspace
);
1680 const char *sym_name
= NULL
;
1681 if (sal
.symbol
!= NULL
)
1682 sym_name
= SYMBOL_PRINT_NAME (sal
.symbol
);
1683 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1684 symtab_to_filename_for_display (sal
.symtab
),
1685 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1688 /* Print a list of files and line numbers which a user may choose from
1689 in order to list a function which was specified ambiguously (as
1690 with `list classname::overloadedfuncname', for example). The SALS
1691 array provides the filenames and line numbers. FORMAT is a
1692 printf-style format string used to tell the user what was
1696 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1697 const char *format
, ...)
1700 va_start (ap
, format
);
1701 vprintf_filtered (format
, ap
);
1704 for (const auto &sal
: sals
)
1705 print_sal_location (sal
);
1708 /* Comparison function for filter_sals. Returns a qsort-style
1712 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1714 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1715 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1723 else if (dirb
== NULL
)
1730 r
= filename_cmp (dira
, dirb
);
1735 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1739 if (sala
.line
< salb
.line
)
1741 return sala
.line
== salb
.line
? 0 : 1;
1744 /* Remove any SALs that do not match the current program space, or
1745 which appear to be "file:line" duplicates. */
1748 filter_sals (std::vector
<symtab_and_line
> &sals
)
1750 /* Remove SALs that do not match. */
1751 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1752 [&] (const symtab_and_line
&sal
)
1753 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1756 std::sort (sals
.begin (), from
,
1757 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1758 { return cmp_symtabs (sala
, salb
) < 0; });
1760 from
= std::unique (sals
.begin (), from
,
1761 [&] (const symtab_and_line
&sala
,
1762 const symtab_and_line
&salb
)
1763 { return cmp_symtabs (sala
, salb
) == 0; });
1765 sals
.erase (from
, sals
.end ());
1769 set_debug (const char *arg
, int from_tty
)
1771 printf_unfiltered (_("\"set debug\" must be followed by "
1772 "the name of a debug subcommand.\n"));
1773 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1777 show_debug (const char *args
, int from_tty
)
1779 cmd_show_list (showdebuglist
, from_tty
, "");
1783 init_cmd_lists (void)
1785 max_user_call_depth
= 1024;
1789 show_info_verbose (struct ui_file
*file
, int from_tty
,
1790 struct cmd_list_element
*c
,
1794 fprintf_filtered (file
,
1795 _("Verbose printing of informational messages is %s.\n"),
1798 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1802 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1803 struct cmd_list_element
*c
, const char *value
)
1805 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1810 show_remote_debug (struct ui_file
*file
, int from_tty
,
1811 struct cmd_list_element
*c
, const char *value
)
1813 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1818 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1819 struct cmd_list_element
*c
, const char *value
)
1821 fprintf_filtered (file
,
1822 _("Timeout limit to wait for target to respond is %s.\n"),
1827 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1828 struct cmd_list_element
*c
, const char *value
)
1830 fprintf_filtered (file
,
1831 _("The max call depth for user-defined commands is %s.\n"),
1836 _initialize_cli_cmds (void)
1838 struct cmd_list_element
*c
;
1840 /* Define the classes of commands.
1841 They will appear in the help list in alphabetical order. */
1843 add_cmd ("internals", class_maintenance
, _("\
1844 Maintenance commands.\n\
1845 Some gdb commands are provided just for use by gdb maintainers.\n\
1846 These commands are subject to frequent change, and may not be as\n\
1847 well documented as user commands."),
1849 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
1850 add_cmd ("aliases", class_alias
,
1851 _("Aliases of other commands."), &cmdlist
);
1852 add_cmd ("user-defined", class_user
, _("\
1853 User-defined commands.\n\
1854 The commands in this class are those defined by the user.\n\
1855 Use the \"define\" command to define a command."), &cmdlist
);
1856 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
1858 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
1859 add_cmd ("files", class_files
, _("Specifying and examining files."),
1861 add_cmd ("breakpoints", class_breakpoint
,
1862 _("Making program stop at certain points."), &cmdlist
);
1863 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
1864 add_cmd ("stack", class_stack
, _("\
1865 Examining the stack.\n\
1866 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1867 counting from zero for the innermost (currently executing) frame.\n\n\
1868 At any time gdb identifies one frame as the \"selected\" frame.\n\
1869 Variable lookups are done with respect to the selected frame.\n\
1870 When the program being debugged stops, gdb selects the innermost frame.\n\
1871 The commands below can be used to select other frames by number or address."),
1873 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
1875 /* Define general commands. */
1877 add_com ("pwd", class_files
, pwd_command
, _("\
1878 Print working directory. This is used for your program as well."));
1880 c
= add_cmd ("cd", class_files
, cd_command
, _("\
1881 Set working directory to DIR for debugger.\n\
1882 The debugger's current working directory specifies where scripts and other\n\
1883 files that can be loaded by GDB are located.\n\
1884 In order to change the inferior's current working directory, the recommended\n\
1885 way is to use the \"set cwd\" command."), &cmdlist
);
1886 set_cmd_completer (c
, filename_completer
);
1888 add_com ("echo", class_support
, echo_command
, _("\
1889 Print a constant string. Give string as argument.\n\
1890 C escape sequences may be used in the argument.\n\
1891 No newline is added at the end of the argument;\n\
1892 use \"\\n\" if you want a newline to be printed.\n\
1893 Since leading and trailing whitespace are ignored in command arguments,\n\
1894 if you want to print some you must use \"\\\" before leading whitespace\n\
1895 to be printed or after trailing whitespace."));
1897 add_setshow_enum_cmd ("script-extension", class_support
,
1898 script_ext_enums
, &script_ext_mode
, _("\
1899 Set mode for script filename extension recognition."), _("\
1900 Show mode for script filename extension recognition."), _("\
1901 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1902 soft == evaluate script according to filename extension, fallback to GDB script"
1904 strict == evaluate script according to filename extension, error if not supported"
1907 show_script_ext_mode
,
1908 &setlist
, &showlist
);
1910 add_com ("quit", class_support
, quit_command
, _("\
1912 Usage: quit [EXPR]\n\
1913 The optional expression EXPR, if present, is evaluated and the result\n\
1914 used as GDB's exit code. The default is zero."));
1915 c
= add_com ("help", class_support
, help_command
,
1916 _("Print list of commands."));
1917 set_cmd_completer (c
, command_completer
);
1918 add_com_alias ("q", "quit", class_support
, 1);
1919 add_com_alias ("h", "help", class_support
, 1);
1921 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
1922 Set verbosity."), _("\
1923 Show verbosity."), NULL
,
1926 &setlist
, &showlist
);
1928 add_prefix_cmd ("history", class_support
, set_history
,
1929 _("Generic command for setting command history parameters."),
1930 &sethistlist
, "set history ", 0, &setlist
);
1931 add_prefix_cmd ("history", class_support
, show_history
,
1932 _("Generic command for showing command history parameters."),
1933 &showhistlist
, "show history ", 0, &showlist
);
1935 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
1936 Set history expansion on command input."), _("\
1937 Show history expansion on command input."), _("\
1938 Without an argument, history expansion is enabled."),
1940 show_history_expansion_p
,
1941 &sethistlist
, &showhistlist
);
1943 add_prefix_cmd ("info", class_info
, info_command
, _("\
1944 Generic command for showing things about the program being debugged."),
1945 &infolist
, "info ", 0, &cmdlist
);
1946 add_com_alias ("i", "info", class_info
, 1);
1947 add_com_alias ("inf", "info", class_info
, 1);
1949 add_com ("complete", class_obscure
, complete_command
,
1950 _("List the completions for the rest of the line as a command."));
1952 add_prefix_cmd ("show", class_info
, show_command
, _("\
1953 Generic command for showing things about the debugger."),
1954 &showlist
, "show ", 0, &cmdlist
);
1955 /* Another way to get at the same thing. */
1956 add_info ("set", show_command
, _("Show all GDB settings."));
1958 c
= add_com ("with", class_vars
, with_command
, _("\
1959 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
1960 Usage: with SETTING [VALUE] [-- COMMAND]\n\
1961 Usage: w SETTING [VALUE] [-- COMMAND]\n\
1962 With no COMMAND, repeats the last executed command.\n\
1964 SETTING is any setting you can change with the \"set\" subcommands.\n\
1966 with language pascal -- print obj\n\
1967 with print elements unlimited -- print obj\n\
1969 You can change multiple settings using nested with, and use\n\
1970 abbreviations for commands and/or values. E.g.:\n\
1971 w la p -- w p el u -- p obj"));
1972 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
1973 add_com_alias ("w", "with", class_vars
, 1);
1975 add_cmd ("commands", no_set_class
, show_commands
, _("\
1976 Show the history of commands you typed.\n\
1977 You can supply a command number to start with, or a `+' to start after\n\
1978 the previous command number shown."),
1981 add_cmd ("version", no_set_class
, show_version
,
1982 _("Show what version of GDB this is."), &showlist
);
1984 add_cmd ("configuration", no_set_class
, show_configuration
,
1985 _("Show how GDB was configured at build time."), &showlist
);
1987 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
1988 Set debugging of remote protocol."), _("\
1989 Show debugging of remote protocol."), _("\
1990 When enabled, each packet sent or received with the remote target\n\
1994 &setdebuglist
, &showdebuglist
);
1996 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
1997 &remote_timeout
, _("\
1998 Set timeout limit to wait for target to respond."), _("\
1999 Show timeout limit to wait for target to respond."), _("\
2000 This value is used to set the time limit for gdb to wait for a response\n\
2003 show_remote_timeout
,
2004 &setlist
, &showlist
);
2006 add_prefix_cmd ("debug", no_class
, set_debug
,
2007 _("Generic command for setting gdb debugging flags"),
2008 &setdebuglist
, "set debug ", 0, &setlist
);
2010 add_prefix_cmd ("debug", no_class
, show_debug
,
2011 _("Generic command for showing gdb debugging flags"),
2012 &showdebuglist
, "show debug ", 0, &showlist
);
2014 c
= add_com ("shell", class_support
, shell_command
, _("\
2015 Execute the rest of the line as a shell command.\n\
2016 With no arguments, run an inferior shell."));
2017 set_cmd_completer (c
, filename_completer
);
2019 add_com_alias ("!", "shell", class_support
, 0);
2021 c
= add_com ("edit", class_files
, edit_command
, _("\
2022 Edit specified file or function.\n\
2023 With no argument, edits file containing most recent line listed.\n\
2024 Editing targets can be specified in these ways:\n\
2025 FILE:LINENUM, to edit at that line in that file,\n\
2026 FUNCTION, to edit at the beginning of that function,\n\
2027 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2028 *ADDRESS, to edit at the line containing that address.\n\
2029 Uses EDITOR environment variable contents as editor (or ex as default)."));
2031 c
->completer
= location_completer
;
2033 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2034 Send the output of a gdb command to a shell command.\n\
2035 Usage: | [COMMAND] | SHELL_COMMAND\n\
2036 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2037 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2038 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2040 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2042 The -d option indicates to use the string DELIM to separate COMMAND\n\
2043 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2044 case COMMAND contains a | character.\n\
2046 With no COMMAND, repeat the last executed command\n\
2047 and send its output to SHELL_COMMAND."));
2048 add_com_alias ("|", "pipe", class_support
, 0);
2050 add_com ("list", class_files
, list_command
, _("\
2051 List specified function or line.\n\
2052 With no argument, lists ten more lines after or around previous listing.\n\
2053 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2054 One argument specifies a line, and ten lines are listed around that line.\n\
2055 Two arguments with comma between specify starting and ending lines to list.\n\
2056 Lines can be specified in these ways:\n\
2057 LINENUM, to list around that line in current file,\n\
2058 FILE:LINENUM, to list around that line in that file,\n\
2059 FUNCTION, to list around beginning of that function,\n\
2060 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2061 *ADDRESS, to list around the line containing that address.\n\
2062 With two args, if one is empty, it stands for ten lines away from\n\
2065 By default, when a single location is given, display ten lines.\n\
2066 This can be changed using \"set listsize\", and the current value\n\
2067 can be shown using \"show listsize\"."));
2069 add_com_alias ("l", "list", class_files
, 1);
2072 add_com_alias ("file", "list", class_files
, 1);
2074 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2075 Disassemble a specified section of memory.\n\
2076 Default is the function surrounding the pc of the selected frame.\n\
2078 With a /m modifier, source lines are included (if available).\n\
2079 This view is \"source centric\": the output is in source line order,\n\
2080 regardless of any optimization that is present. Only the main source file\n\
2081 is displayed, not those of, e.g., any inlined functions.\n\
2082 This modifier hasn't proved useful in practice and is deprecated\n\
2085 With a /s modifier, source lines are included (if available).\n\
2086 This differs from /m in two important respects:\n\
2087 - the output is still in pc address order, and\n\
2088 - file names and contents for all relevant source files are displayed.\n\
2090 With a /r modifier, raw instructions in hex are included.\n\
2092 With a single argument, the function surrounding that address is dumped.\n\
2093 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2094 in the form of \"start,end\", or \"start,+length\".\n\
2096 Note that the address is interpreted as an expression, not as a location\n\
2097 like in the \"break\" command.\n\
2098 So, for example, if you want to disassemble function bar in file foo.c\n\
2099 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2100 set_cmd_completer (c
, location_completer
);
2102 c
= add_com ("make", class_support
, make_command
, _("\
2103 Run the ``make'' program using the rest of the line as arguments."));
2104 set_cmd_completer (c
, filename_completer
);
2105 add_cmd ("user", no_class
, show_user
, _("\
2106 Show definitions of non-python/scheme user defined commands.\n\
2107 Argument is the name of the user defined command.\n\
2108 With no argument, show definitions of all user defined commands."), &showlist
);
2109 add_com ("apropos", class_support
, apropos_command
, _("\
2110 Search for commands matching a REGEXP\n\
2111 Usage: apropos [-v] REGEXP\n\
2112 Flag -v indicates to produce a verbose output, showing full documentation\n\
2113 of the matching commands."));
2115 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2116 &max_user_call_depth
, _("\
2117 Set the max call depth for non-python/scheme user-defined commands."), _("\
2118 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2120 show_max_user_call_depth
,
2121 &setlist
, &showlist
);
2123 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2124 Set tracing of GDB CLI commands."), _("\
2125 Show state of GDB CLI command tracing."), _("\
2126 When 'on', each command is displayed as it is executed."),
2129 &setlist
, &showlist
);
2131 c
= add_com ("alias", class_support
, alias_command
, _("\
2132 Define a new command that is an alias of an existing command.\n\
2133 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2134 ALIAS is the name of the alias command to create.\n\
2135 COMMAND is the command being aliased to.\n\
2136 If \"-a\" is specified, the command is an abbreviation,\n\
2137 and will not appear in help command list output.\n\
2140 Make \"spe\" an alias of \"set print elements\":\n\
2141 alias spe = set print elements\n\
2142 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2143 alias -a set print elms = set print elements"));
2147 init_cli_cmds (void)
2149 struct cmd_list_element
*c
;
2150 char *source_help_text
;
2152 source_help_text
= xstrprintf (_("\
2153 Read commands from a file named FILE.\n\
2155 Usage: source [-s] [-v] FILE\n\
2156 -s: search for the script in the source search path,\n\
2157 even if FILE contains directories.\n\
2158 -v: each command in FILE is echoed as it is executed.\n\
2160 Note that the file \"%s\" is read automatically in this way\n\
2161 when GDB is started."), gdbinit
);
2162 c
= add_cmd ("source", class_support
, source_command
,
2163 source_help_text
, &cmdlist
);
2164 set_cmd_completer (c
, filename_completer
);