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
, "");
215 /* Provide documentation on command or list given by COMMAND. FROM_TTY
219 help_command (const char *command
, int from_tty
)
221 help_cmd (command
, gdb_stdout
);
225 /* Note: The "complete" command is used by Emacs to implement completion.
226 [Is that why this function writes output with *_unfiltered?] */
229 complete_command (const char *arg
, int from_tty
)
233 if (max_completions
== 0)
235 /* Only print this for non-mi frontends. An MI frontend may not
236 be able to handle this. */
237 if (!current_uiout
->is_mi_like_p ())
239 printf_unfiltered (_("max-completions is zero,"
240 " completion is disabled.\n"));
248 int quote_char
= '\0';
251 completion_result result
= complete (arg
, &word
, "e_char
);
253 if (result
.number_matches
!= 0)
255 std::string
arg_prefix (arg
, word
- arg
);
257 if (result
.number_matches
== 1)
258 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
261 result
.sort_match_list ();
263 for (size_t i
= 0; i
< result
.number_matches
; i
++)
265 printf_unfiltered ("%s%s",
267 result
.match_list
[i
+ 1]);
269 printf_unfiltered ("%c", quote_char
);
270 printf_unfiltered ("\n");
274 if (result
.number_matches
== max_completions
)
276 /* ARG_PREFIX and WORD are included in the output so that emacs
277 will include the message in the output. */
278 printf_unfiltered (_("%s%s %s\n"),
279 arg_prefix
.c_str (), word
,
280 get_max_completions_reached_message ());
286 is_complete_command (struct cmd_list_element
*c
)
288 return cmd_cfunc_eq (c
, complete_command
);
292 show_version (const char *args
, int from_tty
)
294 print_gdb_version (gdb_stdout
, true);
295 printf_filtered ("\n");
299 show_configuration (const char *args
, int from_tty
)
301 print_gdb_configuration (gdb_stdout
);
304 /* Handle the quit command. */
307 quit_command (const char *args
, int from_tty
)
311 /* An optional expression may be used to cause gdb to terminate with
312 the value of that expression. */
315 struct value
*val
= parse_and_eval (args
);
317 exit_code
= (int) value_as_long (val
);
320 if (!quit_confirm ())
321 error (_("Not confirmed."));
323 query_if_trace_running (from_tty
);
325 quit_force (args
? &exit_code
: NULL
, from_tty
);
329 pwd_command (const char *args
, int from_tty
)
332 error (_("The \"pwd\" command does not take an argument: %s"), args
);
334 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
337 error (_("Error finding name of working directory: %s"),
338 safe_strerror (errno
));
340 if (strcmp (cwd
.get (), current_directory
) != 0)
341 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
342 current_directory
, cwd
.get ());
344 printf_unfiltered (_("Working directory %s.\n"), current_directory
);
348 cd_command (const char *dir
, int from_tty
)
351 /* Found something other than leading repetitions of "/..". */
355 /* If the new directory is absolute, repeat is a no-op; if relative,
356 repeat might be useful but is more likely to be a mistake. */
359 gdb::unique_xmalloc_ptr
<char> dir_holder
360 (tilde_expand (dir
!= NULL
? dir
: "~"));
361 dir
= dir_holder
.get ();
364 perror_with_name (dir
);
366 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
367 /* There's too much mess with DOSish names like "d:", "d:.",
368 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
369 simply get the canonicalized name of the current directory. */
370 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
375 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
377 /* Remove the trailing slash unless this is a root directory
378 (including a drive letter on non-Unix systems). */
379 if (!(len
== 1) /* "/" */
380 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
381 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
387 dir_holder
.reset (savestring (dir
, len
));
388 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
390 xfree (current_directory
);
391 current_directory
= dir_holder
.release ();
395 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
396 current_directory
= concat (current_directory
, dir_holder
.get (),
399 current_directory
= concat (current_directory
, SLASH_STRING
,
400 dir_holder
.get (), (char *) NULL
);
403 /* Now simplify any occurrences of `.' and `..' in the pathname. */
406 for (p
= current_directory
; *p
;)
408 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
409 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
410 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
411 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
412 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
416 /* Search backwards for the directory just before the "/.."
417 and obliterate it and the "/..". */
420 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
423 if (q
== current_directory
)
424 /* current_directory is
425 a relative pathname ("can't happen"--leave it alone). */
429 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
434 /* We are dealing with leading repetitions of "/..", for
435 example "/../..", which is the Mach super-root. */
445 forget_cached_source_info ();
448 pwd_command ((char *) 0, 1);
451 /* Show the current value of the 'script-extension' option. */
454 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
455 struct cmd_list_element
*c
, const char *value
)
457 fprintf_filtered (file
,
458 _("Script filename extension recognition is \"%s\".\n"),
462 /* Try to open SCRIPT_FILE.
463 If successful, the full path name is stored in *FULL_PATHP,
464 and the stream is returned.
465 If not successful, return NULL; errno is set for the last file
468 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
469 search for it in the source search path. */
471 gdb::optional
<open_script
>
472 find_and_open_script (const char *script_file
, int search_path
)
475 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
476 gdb::optional
<open_script
> opened
;
478 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
481 search_flags
|= OPF_SEARCH_IN_PATH
;
483 /* Search for and open 'file' on the search path used for source
484 files. Put the full location in *FULL_PATHP. */
485 gdb::unique_xmalloc_ptr
<char> full_path
;
486 fd
= openp (source_path
, search_flags
,
487 file
.get (), O_RDONLY
, &full_path
);
492 FILE *result
= fdopen (fd
, FOPEN_RT
);
495 int save_errno
= errno
;
501 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
506 /* Load script FILE, which has already been opened as STREAM.
507 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
508 This is provided as FILE may have been found via the source search path.
509 An important thing to note here is that FILE may be a symlink to a file
510 with a different or non-existing suffix, and thus one cannot infer the
511 extension language from FILE_TO_OPEN. */
514 source_script_from_stream (FILE *stream
, const char *file
,
515 const char *file_to_open
)
517 if (script_ext_mode
!= script_ext_off
)
519 const struct extension_language_defn
*extlang
520 = get_ext_lang_of_file (file
);
524 if (ext_lang_present_p (extlang
))
526 script_sourcer_func
*sourcer
527 = ext_lang_script_sourcer (extlang
);
529 gdb_assert (sourcer
!= NULL
);
530 sourcer (extlang
, stream
, file_to_open
);
533 else if (script_ext_mode
== script_ext_soft
)
535 /* Assume the file is a gdb script.
536 This is handled below. */
539 throw_ext_lang_unsupported (extlang
);
543 script_from_file (stream
, file
);
546 /* Worker to perform the "source" command.
548 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
549 search for it in the source search path. */
552 source_script_with_search (const char *file
, int from_tty
, int search_path
)
555 if (file
== NULL
|| *file
== 0)
556 error (_("source command requires file name of file to source."));
558 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
561 /* The script wasn't found, or was otherwise inaccessible.
562 If the source command was invoked interactively, throw an
563 error. Otherwise (e.g. if it was invoked by a script),
564 just emit a warning, rather than cause an error. */
566 perror_with_name (file
);
569 perror_warning_with_name (file
);
574 /* The python support reopens the file, so we need to pass full_path here
575 in case the file was found on the search path. It's useful to do this
576 anyway so that error messages show the actual file used. But only do
577 this if we (may have) used search_path, as printing the full path in
578 errors for the non-search case can be more noise than signal. */
579 source_script_from_stream (opened
->stream
.get (), file
,
580 search_path
? opened
->full_path
.get () : file
);
583 /* Wrapper around source_script_with_search to export it to main.c
584 for use in loading .gdbinit scripts. */
587 source_script (const char *file
, int from_tty
)
589 source_script_with_search (file
, from_tty
, 0);
593 source_command (const char *args
, int from_tty
)
595 const char *file
= args
;
598 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
600 /* -v causes the source command to run in verbose mode.
601 -s causes the file to be searched in the source search path,
602 even if the file name contains a '/'.
603 We still have to be able to handle filenames with spaces in a
604 backward compatible way, so buildargv is not appropriate. */
608 while (args
[0] != '\0')
610 /* Make sure leading white space does not break the
612 args
= skip_spaces (args
);
617 if (args
[1] == 'v' && isspace (args
[2]))
621 /* Skip passed -v. */
624 else if (args
[1] == 's' && isspace (args
[2]))
628 /* Skip passed -s. */
635 file
= skip_spaces (args
);
638 source_script_with_search (file
, from_tty
, search_path
);
643 echo_command (const char *text
, int from_tty
)
645 const char *p
= text
;
649 while ((c
= *p
++) != '\0')
653 /* \ at end of argument is used after spaces
654 so they won't be lost. */
658 c
= parse_escape (get_current_arch (), &p
);
660 printf_filtered ("%c", c
);
663 printf_filtered ("%c", c
);
666 reset_terminal_style (gdb_stdout
);
668 /* Force this output to appear now. */
670 gdb_flush (gdb_stdout
);
673 /* Sets the last launched shell command convenience variables based on
677 exit_status_set_internal_vars (int exit_status
)
679 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
680 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
682 clear_internalvar (var_code
);
683 clear_internalvar (var_signal
);
684 if (WIFEXITED (exit_status
))
685 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
686 else if (WIFSIGNALED (exit_status
))
687 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
689 warning (_("unexpected shell command exit status %d"), exit_status
);
693 shell_escape (const char *arg
, int from_tty
)
695 #if defined(CANT_FORK) || \
696 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
697 /* If ARG is NULL, they want an inferior shell, but `system' just
698 reports if the shell is available when passed a NULL arg. */
699 int rc
= system (arg
? arg
: "");
702 arg
= "inferior shell";
705 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
706 safe_strerror (errno
));
708 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
710 /* Make sure to return to the directory GDB thinks it is, in case
711 the shell command we just ran changed it. */
712 chdir (current_directory
);
713 exit_status_set_internal_vars (rc
);
715 #else /* Can fork. */
718 if ((pid
= vfork ()) == 0)
720 const char *p
, *user_shell
= get_shell ();
724 /* Get the name of the shell for arg0. */
725 p
= lbasename (user_shell
);
728 execl (user_shell
, p
, (char *) 0);
730 execl (user_shell
, p
, "-c", arg
, (char *) 0);
732 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
733 safe_strerror (errno
));
738 waitpid (pid
, &status
, 0);
740 error (_("Fork failed"));
741 exit_status_set_internal_vars (status
);
742 #endif /* Can fork. */
745 /* Implementation of the "shell" command. */
748 shell_command (const char *arg
, int from_tty
)
750 shell_escape (arg
, from_tty
);
754 edit_command (const char *arg
, int from_tty
)
756 struct symtab_and_line sal
;
762 /* Pull in the current default source line if necessary. */
765 set_default_source_symtab_and_line ();
766 sal
= get_current_source_symtab_and_line ();
769 /* Bare "edit" edits file with present line. */
774 error (_("No default source file yet."));
775 sal
.line
+= get_lines_to_list () / 2;
781 /* Now should only be one argument -- decode it in SAL. */
783 event_location_up location
= string_to_event_location (&arg1
,
785 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
786 DECODE_LINE_LIST_MODE
,
795 if (sals
.size () > 1)
797 ambiguous_line_spec (sals
,
798 _("Specified line is ambiguous:\n"));
805 error (_("Junk at end of line specification."));
807 /* If line was specified by address, first print exactly which
808 line, and which file. In this case, sal.symtab == 0 means
809 address is outside of all known source files, not that user
810 failed to give a filename. */
813 struct gdbarch
*gdbarch
;
816 error (_("No source file for address %s."),
817 paddress (get_current_arch (), sal
.pc
));
819 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
820 sym
= find_pc_function (sal
.pc
);
822 printf_filtered ("%s is in %s (%s:%d).\n",
823 paddress (gdbarch
, sal
.pc
),
824 SYMBOL_PRINT_NAME (sym
),
825 symtab_to_filename_for_display (sal
.symtab
),
828 printf_filtered ("%s is at %s:%d.\n",
829 paddress (gdbarch
, sal
.pc
),
830 symtab_to_filename_for_display (sal
.symtab
),
834 /* If what was given does not imply a symtab, it must be an
835 undebuggable symbol which means no source code. */
838 error (_("No line number known for %s."), arg
);
841 if ((editor
= getenv ("EDITOR")) == NULL
)
844 fn
= symtab_to_fullname (sal
.symtab
);
846 /* Quote the file name, in case it has whitespace or other special
848 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
849 shell_escape (p
, from_tty
);
853 /* Implementation of the "pipe" command. */
856 pipe_command (const char *arg
, int from_tty
)
858 std::string
delim ("|");
860 if (arg
!= nullptr && check_for_argument (&arg
, "-d", 2))
862 delim
= extract_arg (&arg
);
864 error (_("Missing delimiter DELIM after -d"));
867 const char *command
= arg
;
868 if (command
== nullptr)
869 error (_("Missing COMMAND"));
871 arg
= strstr (arg
, delim
.c_str ());
874 error (_("Missing delimiter before SHELL_COMMAND"));
876 std::string
gdb_cmd (command
, arg
- command
);
878 arg
+= delim
.length (); /* Skip the delimiter. */
880 if (gdb_cmd
.empty ())
883 gdb_cmd
= skip_spaces (get_saved_command_line ());
884 if (gdb_cmd
.empty ())
885 error (_("No previous command to relaunch"));
888 const char *shell_command
= skip_spaces (arg
);
889 if (*shell_command
== '\0')
890 error (_("Missing SHELL_COMMAND"));
892 FILE *to_shell_command
= popen (shell_command
, "w");
894 if (to_shell_command
== nullptr)
895 error (_("Error launching \"%s\""), shell_command
);
899 stdio_file
pipe_file (to_shell_command
);
901 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
905 pclose (to_shell_command
);
909 int exit_status
= pclose (to_shell_command
);
912 error (_("shell command \"%s\" failed: %s"), shell_command
,
913 safe_strerror (errno
));
914 exit_status_set_internal_vars (exit_status
);
918 list_command (const char *arg
, int from_tty
)
928 /* Pull in the current default source line if necessary. */
929 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
931 set_default_source_symtab_and_line ();
932 symtab_and_line cursal
= get_current_source_symtab_and_line ();
934 /* If this is the first "list" since we've set the current
935 source line, center the listing around that line. */
936 if (get_first_line_listed () == 0)
940 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
942 /* A small special case --- if listing backwards, and we
943 should list only one line, list the preceding line,
944 instead of the exact line we've just shown after e.g.,
945 stopping for a breakpoint. */
946 if (arg
!= NULL
&& arg
[0] == '-'
947 && get_lines_to_list () == 1 && first
> 1)
950 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
953 /* "l" or "l +" lists next ten lines. */
954 else if (arg
== NULL
|| arg
[0] == '+')
955 print_source_lines (cursal
.symtab
,
956 source_lines_range (cursal
.line
), 0);
958 /* "l -" lists previous ten lines, the ones before the ten just
960 else if (arg
[0] == '-')
962 if (get_first_line_listed () == 1)
963 error (_("Already at the start of %s."),
964 symtab_to_filename_for_display (cursal
.symtab
));
965 source_lines_range
range (get_first_line_listed (),
966 source_lines_range::BACKWARD
);
967 print_source_lines (cursal
.symtab
, range
, 0);
973 /* Now if there is only one argument, decode it in SAL
975 If there are two arguments, decode them in SAL and SAL_END
976 and clear NO_END; however, if one of the arguments is blank,
977 set DUMMY_BEG or DUMMY_END to record that fact. */
979 if (!have_full_symbols () && !have_partial_symbols ())
980 error (_("No symbol table is loaded. Use the \"file\" command."));
982 std::vector
<symtab_and_line
> sals
;
983 symtab_and_line sal
, sal_end
;
990 event_location_up location
= string_to_event_location (&arg1
,
992 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1004 /* Record whether the BEG arg is all digits. */
1006 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1007 linenum_beg
= (p
== arg1
);
1009 /* Save the range of the first argument, in case we need to let the
1010 user know it was ambiguous. */
1011 const char *beg
= arg
;
1012 size_t beg_len
= arg1
- beg
;
1014 while (*arg1
== ' ' || *arg1
== '\t')
1019 if (sals
.size () > 1)
1021 ambiguous_line_spec (sals
,
1022 _("Specified first line '%.*s' is ambiguous:\n"),
1023 (int) beg_len
, beg
);
1027 while (*arg1
== ' ' || *arg1
== '\t')
1033 /* Save the last argument, in case we need to let the user
1034 know it was ambiguous. */
1035 const char *end_arg
= arg1
;
1037 event_location_up location
1038 = string_to_event_location (&arg1
, current_language
);
1040 std::vector
<symtab_and_line
> sals_end
1042 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1044 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1045 NULL
, sal
.symtab
, sal
.line
));
1047 filter_sals (sals_end
);
1048 if (sals_end
.empty ())
1050 if (sals_end
.size () > 1)
1052 ambiguous_line_spec (sals_end
,
1053 _("Specified last line '%s' is ambiguous:\n"),
1057 sal_end
= sals_end
[0];
1062 error (_("Junk at end of line specification."));
1064 if (!no_end
&& !dummy_beg
&& !dummy_end
1065 && sal
.symtab
!= sal_end
.symtab
)
1066 error (_("Specified first and last lines are in different files."));
1067 if (dummy_beg
&& dummy_end
)
1068 error (_("Two empty args do not say what lines to list."));
1070 /* If line was specified by address,
1071 first print exactly which line, and which file.
1073 In this case, sal.symtab == 0 means address is outside of all
1074 known source files, not that user failed to give a filename. */
1077 struct gdbarch
*gdbarch
;
1079 if (sal
.symtab
== 0)
1080 error (_("No source file for address %s."),
1081 paddress (get_current_arch (), sal
.pc
));
1083 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1084 sym
= find_pc_function (sal
.pc
);
1086 printf_filtered ("%s is in %s (%s:%d).\n",
1087 paddress (gdbarch
, sal
.pc
),
1088 SYMBOL_PRINT_NAME (sym
),
1089 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1091 printf_filtered ("%s is at %s:%d.\n",
1092 paddress (gdbarch
, sal
.pc
),
1093 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1096 /* If line was not specified by just a line number, and it does not
1097 imply a symtab, it must be an undebuggable symbol which means no
1100 if (!linenum_beg
&& sal
.symtab
== 0)
1101 error (_("No line number known for %s."), arg
);
1103 /* If this command is repeated with RET,
1104 turn it into the no-arg variant. */
1107 set_repeat_arguments ("");
1109 if (dummy_beg
&& sal_end
.symtab
== 0)
1110 error (_("No default source file yet. Do \"help list\"."));
1113 source_lines_range
range (sal_end
.line
+ 1,
1114 source_lines_range::BACKWARD
);
1115 print_source_lines (sal_end
.symtab
, range
, 0);
1117 else if (sal
.symtab
== 0)
1118 error (_("No default source file yet. Do \"help list\"."));
1121 for (int i
= 0; i
< sals
.size (); i
++)
1124 int first_line
= sal
.line
- get_lines_to_list () / 2;
1127 if (sals
.size () > 1)
1128 print_sal_location (sal
);
1129 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1133 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1135 print_source_lines (sal
.symtab
,
1136 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1140 /* Subroutine of disassemble_command to simplify it.
1141 Perform the disassembly.
1142 NAME is the name of the function if known, or NULL.
1143 [LOW,HIGH) are the range of addresses to disassemble.
1144 BLOCK is the block to disassemble; it needs to be provided
1145 when non-contiguous blocks are disassembled; otherwise
1147 MIXED is non-zero to print source with the assembler. */
1150 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1151 CORE_ADDR low
, CORE_ADDR high
,
1152 const struct block
*block
,
1153 gdb_disassembly_flags flags
)
1156 if (!tui_is_window_visible (DISASSEM_WIN
))
1159 printf_filtered ("Dump of assembler code ");
1161 printf_filtered ("for function %s:\n", name
);
1162 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1165 printf_filtered ("from %s to %s:\n",
1166 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1168 /* Dump the specified range. */
1169 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1173 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1175 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1176 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1177 printf_filtered (_("Address range %s to %s:\n"),
1178 paddress (gdbarch
, range_low
),
1179 paddress (gdbarch
, range_high
));
1180 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1181 range_low
, range_high
);
1184 printf_filtered ("End of assembler dump.\n");
1189 tui_show_assembly (gdbarch
, low
);
1194 /* Subroutine of disassemble_command to simplify it.
1195 Print a disassembly of the current function according to FLAGS. */
1198 disassemble_current_function (gdb_disassembly_flags flags
)
1200 struct frame_info
*frame
;
1201 struct gdbarch
*gdbarch
;
1202 CORE_ADDR low
, high
, pc
;
1204 const struct block
*block
;
1206 frame
= get_selected_frame (_("No frame selected."));
1207 gdbarch
= get_frame_arch (frame
);
1208 pc
= get_frame_address_in_block (frame
);
1209 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1210 error (_("No function contains program counter for selected frame."));
1212 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1215 /* FIXME: cagney/2004-02-07: This should be an observer. */
1216 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1218 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1220 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1223 /* Dump a specified section of assembly code.
1227 - dump the assembly code for the function of the current pc
1228 disassemble [/mrs] addr
1229 - dump the assembly code for the function at ADDR
1230 disassemble [/mrs] low,high
1231 disassemble [/mrs] low,+length
1232 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1234 A /m modifier will include source code with the assembly in a
1235 "source centric" view. This view lists only the file of the first insn,
1236 even if other source files are involved (e.g., inlined functions), and
1237 the output is in source order, even with optimized code. This view is
1238 considered deprecated as it hasn't been useful in practice.
1240 A /r modifier will include raw instructions in hex with the assembly.
1242 A /s modifier will include source code with the assembly, like /m, with
1243 two important differences:
1244 1) The output is still in pc address order.
1245 2) File names and contents for all relevant source files are displayed. */
1248 disassemble_command (const char *arg
, int from_tty
)
1250 struct gdbarch
*gdbarch
= get_current_arch ();
1251 CORE_ADDR low
, high
;
1254 gdb_disassembly_flags flags
;
1256 const struct block
*block
= nullptr;
1267 error (_("Missing modifier."));
1269 while (*p
&& ! isspace (*p
))
1274 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1277 flags
|= DISASSEMBLY_RAW_INSN
;
1280 flags
|= DISASSEMBLY_SOURCE
;
1283 error (_("Invalid disassembly modifier."));
1287 p
= skip_spaces (p
);
1290 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1291 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1292 error (_("Cannot specify both /m and /s."));
1296 flags
|= DISASSEMBLY_OMIT_FNAME
;
1297 disassemble_current_function (flags
);
1301 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1307 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1308 error (_("No function contains specified address."));
1310 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1313 /* FIXME: cagney/2004-02-07: This should be an observer. */
1314 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1316 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1317 flags
|= DISASSEMBLY_OMIT_FNAME
;
1321 /* Two arguments. */
1324 p
= skip_spaces (p
);
1330 high
= parse_and_eval_address (p
);
1335 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1339 make_command (const char *arg
, int from_tty
)
1342 shell_escape ("make", from_tty
);
1345 std::string cmd
= std::string ("make ") + arg
;
1347 shell_escape (cmd
.c_str (), from_tty
);
1352 show_user (const char *args
, int from_tty
)
1354 struct cmd_list_element
*c
;
1355 extern struct cmd_list_element
*cmdlist
;
1359 const char *comname
= args
;
1361 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1362 if (!cli_user_command_p (c
))
1363 error (_("Not a user command."));
1364 show_user_1 (c
, "", args
, gdb_stdout
);
1368 for (c
= cmdlist
; c
; c
= c
->next
)
1370 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1371 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1376 /* Search through names of commands and documentations for a certain
1377 regular expression. */
1380 apropos_command (const char *arg
, int from_tty
)
1382 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1384 if (arg
== NULL
|| *arg
== '\0')
1385 error (_("REGEXP string is empty"));
1387 compiled_regex
pattern (arg
, REG_ICASE
,
1388 _("Error in regular expression"));
1390 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1393 /* Subroutine of alias_command to simplify it.
1394 Return the first N elements of ARGV flattened back to a string
1395 with a space separating each element.
1396 ARGV may not be NULL.
1397 This does not take care of quoting elements in case they contain spaces
1401 argv_to_string (char **argv
, int n
)
1406 gdb_assert (argv
!= NULL
);
1407 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1409 for (i
= 0; i
< n
; ++i
)
1419 /* Subroutine of alias_command to simplify it.
1420 Return true if COMMAND exists, unambiguously. Otherwise false. */
1423 valid_command_p (const char *command
)
1425 struct cmd_list_element
*c
;
1427 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1429 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1432 /* This is the slightly tricky part.
1433 lookup_cmd_1 will return a pointer to the last part of COMMAND
1434 to match, leaving COMMAND pointing at the remainder. */
1435 while (*command
== ' ' || *command
== '\t')
1437 return *command
== '\0';
1440 /* Called when "alias" was incorrectly used. */
1443 alias_usage_error (void)
1445 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1448 /* Make an alias of an existing command. */
1451 alias_command (const char *args
, int from_tty
)
1453 int i
, alias_argc
, command_argc
;
1454 int abbrev_flag
= 0;
1456 const char *alias
, *command
;
1458 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1459 alias_usage_error ();
1461 equals
= strchr (args
, '=');
1462 std::string
args2 (args
, equals
- args
);
1464 gdb_argv
built_alias_argv (args2
.c_str ());
1465 gdb_argv
command_argv (equals
+ 1);
1467 char **alias_argv
= built_alias_argv
.get ();
1468 while (alias_argv
[0] != NULL
)
1470 if (strcmp (alias_argv
[0], "-a") == 0)
1475 else if (strcmp (alias_argv
[0], "--") == 0)
1484 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1485 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1486 alias_usage_error ();
1488 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1490 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1493 error (_("Invalid command name: %s"), alias_argv
[i
]);
1495 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1499 alias_argc
= countargv (alias_argv
);
1500 command_argc
= command_argv
.count ();
1502 /* COMMAND must exist.
1503 Reconstruct the command to remove any extraneous spaces,
1504 for better error messages. */
1505 std::string
command_string (argv_to_string (command_argv
.get (),
1507 command
= command_string
.c_str ();
1508 if (! valid_command_p (command
))
1509 error (_("Invalid command to alias to: %s"), command
);
1511 /* ALIAS must not exist. */
1512 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1513 alias
= alias_string
.c_str ();
1514 if (valid_command_p (alias
))
1515 error (_("Alias already exists: %s"), alias
);
1517 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1518 Example: alias spe = set print elements
1520 Otherwise ALIAS and COMMAND must have the same number of words,
1521 and every word except the last must identify the same prefix command;
1522 and the last word of ALIAS is made an alias of the last word of COMMAND.
1523 Example: alias set print elms = set pr elem
1524 Note that unambiguous abbreviations are allowed. */
1526 if (alias_argc
== 1)
1528 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1529 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1534 const char *alias_prefix
, *command_prefix
;
1535 struct cmd_list_element
*c_alias
, *c_command
;
1537 if (alias_argc
!= command_argc
)
1538 error (_("Mismatched command length between ALIAS and COMMAND."));
1540 /* Create copies of ALIAS and COMMAND without the last word,
1541 and use that to verify the leading elements give the same
1543 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1545 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1547 alias_prefix
= alias_prefix_string
.c_str ();
1548 command_prefix
= command_prefix_string
.c_str ();
1550 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1551 /* We've already tried to look up COMMAND. */
1552 gdb_assert (c_command
!= NULL
1553 && c_command
!= (struct cmd_list_element
*) -1);
1554 gdb_assert (c_command
->prefixlist
!= NULL
);
1555 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1556 if (c_alias
!= c_command
)
1557 error (_("ALIAS and COMMAND prefixes do not match."));
1559 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1560 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1561 command_argv
[command_argc
- 1],
1562 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1566 /* Print the file / line number / symbol name of the location
1567 specified by SAL. */
1570 print_sal_location (const symtab_and_line
&sal
)
1572 scoped_restore_current_program_space restore_pspace
;
1573 set_current_program_space (sal
.pspace
);
1575 const char *sym_name
= NULL
;
1576 if (sal
.symbol
!= NULL
)
1577 sym_name
= SYMBOL_PRINT_NAME (sal
.symbol
);
1578 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1579 symtab_to_filename_for_display (sal
.symtab
),
1580 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1583 /* Print a list of files and line numbers which a user may choose from
1584 in order to list a function which was specified ambiguously (as
1585 with `list classname::overloadedfuncname', for example). The SALS
1586 array provides the filenames and line numbers. FORMAT is a
1587 printf-style format string used to tell the user what was
1591 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1592 const char *format
, ...)
1595 va_start (ap
, format
);
1596 vprintf_filtered (format
, ap
);
1599 for (const auto &sal
: sals
)
1600 print_sal_location (sal
);
1603 /* Comparison function for filter_sals. Returns a qsort-style
1607 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1609 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1610 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1618 else if (dirb
== NULL
)
1625 r
= filename_cmp (dira
, dirb
);
1630 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1634 if (sala
.line
< salb
.line
)
1636 return sala
.line
== salb
.line
? 0 : 1;
1639 /* Remove any SALs that do not match the current program space, or
1640 which appear to be "file:line" duplicates. */
1643 filter_sals (std::vector
<symtab_and_line
> &sals
)
1645 /* Remove SALs that do not match. */
1646 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1647 [&] (const symtab_and_line
&sal
)
1648 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1651 std::sort (sals
.begin (), from
,
1652 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1653 { return cmp_symtabs (sala
, salb
) < 0; });
1655 from
= std::unique (sals
.begin (), from
,
1656 [&] (const symtab_and_line
&sala
,
1657 const symtab_and_line
&salb
)
1658 { return cmp_symtabs (sala
, salb
) == 0; });
1660 sals
.erase (from
, sals
.end ());
1664 set_debug (const char *arg
, int from_tty
)
1666 printf_unfiltered (_("\"set debug\" must be followed by "
1667 "the name of a debug subcommand.\n"));
1668 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1672 show_debug (const char *args
, int from_tty
)
1674 cmd_show_list (showdebuglist
, from_tty
, "");
1678 init_cmd_lists (void)
1680 max_user_call_depth
= 1024;
1684 show_info_verbose (struct ui_file
*file
, int from_tty
,
1685 struct cmd_list_element
*c
,
1689 fprintf_filtered (file
,
1690 _("Verbose printing of informational messages is %s.\n"),
1693 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1697 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1698 struct cmd_list_element
*c
, const char *value
)
1700 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1705 show_remote_debug (struct ui_file
*file
, int from_tty
,
1706 struct cmd_list_element
*c
, const char *value
)
1708 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1713 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1714 struct cmd_list_element
*c
, const char *value
)
1716 fprintf_filtered (file
,
1717 _("Timeout limit to wait for target to respond is %s.\n"),
1722 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1723 struct cmd_list_element
*c
, const char *value
)
1725 fprintf_filtered (file
,
1726 _("The max call depth for user-defined commands is %s.\n"),
1731 _initialize_cli_cmds (void)
1733 struct cmd_list_element
*c
;
1735 /* Define the classes of commands.
1736 They will appear in the help list in alphabetical order. */
1738 add_cmd ("internals", class_maintenance
, _("\
1739 Maintenance commands.\n\
1740 Some gdb commands are provided just for use by gdb maintainers.\n\
1741 These commands are subject to frequent change, and may not be as\n\
1742 well documented as user commands."),
1744 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
1745 add_cmd ("aliases", class_alias
,
1746 _("Aliases of other commands."), &cmdlist
);
1747 add_cmd ("user-defined", class_user
, _("\
1748 User-defined commands.\n\
1749 The commands in this class are those defined by the user.\n\
1750 Use the \"define\" command to define a command."), &cmdlist
);
1751 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
1753 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
1754 add_cmd ("files", class_files
, _("Specifying and examining files."),
1756 add_cmd ("breakpoints", class_breakpoint
,
1757 _("Making program stop at certain points."), &cmdlist
);
1758 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
1759 add_cmd ("stack", class_stack
, _("\
1760 Examining the stack.\n\
1761 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1762 counting from zero for the innermost (currently executing) frame.\n\n\
1763 At any time gdb identifies one frame as the \"selected\" frame.\n\
1764 Variable lookups are done with respect to the selected frame.\n\
1765 When the program being debugged stops, gdb selects the innermost frame.\n\
1766 The commands below can be used to select other frames by number or address."),
1768 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
1770 /* Define general commands. */
1772 add_com ("pwd", class_files
, pwd_command
, _("\
1773 Print working directory. This is used for your program as well."));
1775 c
= add_cmd ("cd", class_files
, cd_command
, _("\
1776 Set working directory to DIR for debugger.\n\
1777 The debugger's current working directory specifies where scripts and other\n\
1778 files that can be loaded by GDB are located.\n\
1779 In order to change the inferior's current working directory, the recommended\n\
1780 way is to use the \"set cwd\" command."), &cmdlist
);
1781 set_cmd_completer (c
, filename_completer
);
1783 add_com ("echo", class_support
, echo_command
, _("\
1784 Print a constant string. Give string as argument.\n\
1785 C escape sequences may be used in the argument.\n\
1786 No newline is added at the end of the argument;\n\
1787 use \"\\n\" if you want a newline to be printed.\n\
1788 Since leading and trailing whitespace are ignored in command arguments,\n\
1789 if you want to print some you must use \"\\\" before leading whitespace\n\
1790 to be printed or after trailing whitespace."));
1792 add_setshow_enum_cmd ("script-extension", class_support
,
1793 script_ext_enums
, &script_ext_mode
, _("\
1794 Set mode for script filename extension recognition."), _("\
1795 Show mode for script filename extension recognition."), _("\
1796 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1797 soft == evaluate script according to filename extension, fallback to GDB script"
1799 strict == evaluate script according to filename extension, error if not supported"
1802 show_script_ext_mode
,
1803 &setlist
, &showlist
);
1805 add_com ("quit", class_support
, quit_command
, _("\
1807 Usage: quit [EXPR]\n\
1808 The optional expression EXPR, if present, is evaluated and the result\n\
1809 used as GDB's exit code. The default is zero."));
1810 c
= add_com ("help", class_support
, help_command
,
1811 _("Print list of commands."));
1812 set_cmd_completer (c
, command_completer
);
1813 add_com_alias ("q", "quit", class_support
, 1);
1814 add_com_alias ("h", "help", class_support
, 1);
1816 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
1817 Set verbosity."), _("\
1818 Show verbosity."), NULL
,
1821 &setlist
, &showlist
);
1823 add_prefix_cmd ("history", class_support
, set_history
,
1824 _("Generic command for setting command history parameters."),
1825 &sethistlist
, "set history ", 0, &setlist
);
1826 add_prefix_cmd ("history", class_support
, show_history
,
1827 _("Generic command for showing command history parameters."),
1828 &showhistlist
, "show history ", 0, &showlist
);
1830 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
1831 Set history expansion on command input."), _("\
1832 Show history expansion on command input."), _("\
1833 Without an argument, history expansion is enabled."),
1835 show_history_expansion_p
,
1836 &sethistlist
, &showhistlist
);
1838 add_prefix_cmd ("info", class_info
, info_command
, _("\
1839 Generic command for showing things about the program being debugged."),
1840 &infolist
, "info ", 0, &cmdlist
);
1841 add_com_alias ("i", "info", class_info
, 1);
1842 add_com_alias ("inf", "info", class_info
, 1);
1844 add_com ("complete", class_obscure
, complete_command
,
1845 _("List the completions for the rest of the line as a command."));
1847 add_prefix_cmd ("show", class_info
, show_command
, _("\
1848 Generic command for showing things about the debugger."),
1849 &showlist
, "show ", 0, &cmdlist
);
1850 /* Another way to get at the same thing. */
1851 add_info ("set", show_command
, _("Show all GDB settings."));
1853 add_cmd ("commands", no_set_class
, show_commands
, _("\
1854 Show the history of commands you typed.\n\
1855 You can supply a command number to start with, or a `+' to start after\n\
1856 the previous command number shown."),
1859 add_cmd ("version", no_set_class
, show_version
,
1860 _("Show what version of GDB this is."), &showlist
);
1862 add_cmd ("configuration", no_set_class
, show_configuration
,
1863 _("Show how GDB was configured at build time."), &showlist
);
1865 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
1866 Set debugging of remote protocol."), _("\
1867 Show debugging of remote protocol."), _("\
1868 When enabled, each packet sent or received with the remote target\n\
1872 &setdebuglist
, &showdebuglist
);
1874 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
1875 &remote_timeout
, _("\
1876 Set timeout limit to wait for target to respond."), _("\
1877 Show timeout limit to wait for target to respond."), _("\
1878 This value is used to set the time limit for gdb to wait for a response\n\
1881 show_remote_timeout
,
1882 &setlist
, &showlist
);
1884 add_prefix_cmd ("debug", no_class
, set_debug
,
1885 _("Generic command for setting gdb debugging flags"),
1886 &setdebuglist
, "set debug ", 0, &setlist
);
1888 add_prefix_cmd ("debug", no_class
, show_debug
,
1889 _("Generic command for showing gdb debugging flags"),
1890 &showdebuglist
, "show debug ", 0, &showlist
);
1892 c
= add_com ("shell", class_support
, shell_command
, _("\
1893 Execute the rest of the line as a shell command.\n\
1894 With no arguments, run an inferior shell."));
1895 set_cmd_completer (c
, filename_completer
);
1897 add_com_alias ("!", "shell", class_support
, 0);
1899 c
= add_com ("edit", class_files
, edit_command
, _("\
1900 Edit specified file or function.\n\
1901 With no argument, edits file containing most recent line listed.\n\
1902 Editing targets can be specified in these ways:\n\
1903 FILE:LINENUM, to edit at that line in that file,\n\
1904 FUNCTION, to edit at the beginning of that function,\n\
1905 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1906 *ADDRESS, to edit at the line containing that address.\n\
1907 Uses EDITOR environment variable contents as editor (or ex as default)."));
1909 c
->completer
= location_completer
;
1911 c
= add_com ("pipe", class_support
, pipe_command
, _("\
1912 Send the output of a gdb command to a shell command.\n\
1913 Usage: | [COMMAND] | SHELL_COMMAND\n\
1914 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
1915 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
1916 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
1918 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
1920 The -d option indicates to use the string DELIM to separate COMMAND\n\
1921 from SHELL_COMMAND, in alternative to |. This is useful in\n\
1922 case COMMAND contains a | character.\n\
1924 With no COMMAND, repeat the last executed command\n\
1925 and send its output to SHELL_COMMAND."));
1926 add_com_alias ("|", "pipe", class_support
, 0);
1928 add_com ("list", class_files
, list_command
, _("\
1929 List specified function or line.\n\
1930 With no argument, lists ten more lines after or around previous listing.\n\
1931 \"list -\" lists the ten lines before a previous ten-line listing.\n\
1932 One argument specifies a line, and ten lines are listed around that line.\n\
1933 Two arguments with comma between specify starting and ending lines to list.\n\
1934 Lines can be specified in these ways:\n\
1935 LINENUM, to list around that line in current file,\n\
1936 FILE:LINENUM, to list around that line in that file,\n\
1937 FUNCTION, to list around beginning of that function,\n\
1938 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1939 *ADDRESS, to list around the line containing that address.\n\
1940 With two args, if one is empty, it stands for ten lines away from\n\
1943 By default, when a single location is given, display ten lines.\n\
1944 This can be changed using \"set listsize\", and the current value\n\
1945 can be shown using \"show listsize\"."));
1947 add_com_alias ("l", "list", class_files
, 1);
1950 add_com_alias ("file", "list", class_files
, 1);
1952 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
1953 Disassemble a specified section of memory.\n\
1954 Default is the function surrounding the pc of the selected frame.\n\
1956 With a /m modifier, source lines are included (if available).\n\
1957 This view is \"source centric\": the output is in source line order,\n\
1958 regardless of any optimization that is present. Only the main source file\n\
1959 is displayed, not those of, e.g., any inlined functions.\n\
1960 This modifier hasn't proved useful in practice and is deprecated\n\
1963 With a /s modifier, source lines are included (if available).\n\
1964 This differs from /m in two important respects:\n\
1965 - the output is still in pc address order, and\n\
1966 - file names and contents for all relevant source files are displayed.\n\
1968 With a /r modifier, raw instructions in hex are included.\n\
1970 With a single argument, the function surrounding that address is dumped.\n\
1971 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
1972 in the form of \"start,end\", or \"start,+length\".\n\
1974 Note that the address is interpreted as an expression, not as a location\n\
1975 like in the \"break\" command.\n\
1976 So, for example, if you want to disassemble function bar in file foo.c\n\
1977 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
1978 set_cmd_completer (c
, location_completer
);
1980 c
= add_com ("make", class_support
, make_command
, _("\
1981 Run the ``make'' program using the rest of the line as arguments."));
1982 set_cmd_completer (c
, filename_completer
);
1983 add_cmd ("user", no_class
, show_user
, _("\
1984 Show definitions of non-python/scheme user defined commands.\n\
1985 Argument is the name of the user defined command.\n\
1986 With no argument, show definitions of all user defined commands."), &showlist
);
1987 add_com ("apropos", class_support
, apropos_command
, _("\
1988 Search for commands matching a REGEXP\n\
1989 Usage: apropos [-v] REGEXP\n\
1990 Flag -v indicates to produce a verbose output, showing full documentation\n\
1991 of the matching commands."));
1993 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
1994 &max_user_call_depth
, _("\
1995 Set the max call depth for non-python/scheme user-defined commands."), _("\
1996 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
1998 show_max_user_call_depth
,
1999 &setlist
, &showlist
);
2001 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2002 Set tracing of GDB CLI commands."), _("\
2003 Show state of GDB CLI command tracing."), _("\
2004 When 'on', each command is displayed as it is executed."),
2007 &setlist
, &showlist
);
2009 c
= add_com ("alias", class_support
, alias_command
, _("\
2010 Define a new command that is an alias of an existing command.\n\
2011 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2012 ALIAS is the name of the alias command to create.\n\
2013 COMMAND is the command being aliased to.\n\
2014 If \"-a\" is specified, the command is an abbreviation,\n\
2015 and will not appear in help command list output.\n\
2018 Make \"spe\" an alias of \"set print elements\":\n\
2019 alias spe = set print elements\n\
2020 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2021 alias -a set print elms = set print elements"));
2025 init_cli_cmds (void)
2027 struct cmd_list_element
*c
;
2028 char *source_help_text
;
2030 source_help_text
= xstrprintf (_("\
2031 Read commands from a file named FILE.\n\
2033 Usage: source [-s] [-v] FILE\n\
2034 -s: search for the script in the source search path,\n\
2035 even if FILE contains directories.\n\
2036 -v: each command in FILE is echoed as it is executed.\n\
2038 Note that the file \"%s\" is read automatically in this way\n\
2039 when GDB is started."), gdbinit
);
2040 c
= add_cmd ("source", class_support
, source_command
,
2041 source_help_text
, &cmdlist
);
2042 set_cmd_completer (c
, filename_completer
);