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. */
27 #include "gdb_regex.h" /* Used by apropos_command. */
28 #include "gdb_vfork.h"
30 #include "expression.h"
34 #include "filenames.h" /* For DOSish file names. */
38 #include "tracepoint.h"
39 #include "common/filestuff.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-script.h"
48 #include "cli/cli-setshow.h"
49 #include "cli/cli-cmds.h"
50 #include "cli/cli-utils.h"
52 #include "extension.h"
53 #include "common/pathstuff.h"
56 #include "tui/tui.h" /* For tui_active et.al. */
63 /* Prototypes for local utility functions */
65 static void print_sal_location (const symtab_and_line
&sal
);
67 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
68 const char *format
, ...)
69 ATTRIBUTE_PRINTF (2, 3);
71 static void filter_sals (std::vector
<symtab_and_line
> &);
74 /* Limit the call depth of user-defined commands */
75 unsigned int max_user_call_depth
;
77 /* Define all cmd_list_elements. */
79 /* Chain containing all defined commands. */
81 struct cmd_list_element
*cmdlist
;
83 /* Chain containing all defined info subcommands. */
85 struct cmd_list_element
*infolist
;
87 /* Chain containing all defined enable subcommands. */
89 struct cmd_list_element
*enablelist
;
91 /* Chain containing all defined disable subcommands. */
93 struct cmd_list_element
*disablelist
;
95 /* Chain containing all defined stop subcommands. */
97 struct cmd_list_element
*stoplist
;
99 /* Chain containing all defined delete subcommands. */
101 struct cmd_list_element
*deletelist
;
103 /* Chain containing all defined detach subcommands. */
105 struct cmd_list_element
*detachlist
;
107 /* Chain containing all defined kill subcommands. */
109 struct cmd_list_element
*killlist
;
111 /* Chain containing all defined set subcommands */
113 struct cmd_list_element
*setlist
;
115 /* Chain containing all defined unset subcommands */
117 struct cmd_list_element
*unsetlist
;
119 /* Chain containing all defined show subcommands. */
121 struct cmd_list_element
*showlist
;
123 /* Chain containing all defined \"set history\". */
125 struct cmd_list_element
*sethistlist
;
127 /* Chain containing all defined \"show history\". */
129 struct cmd_list_element
*showhistlist
;
131 /* Chain containing all defined \"unset history\". */
133 struct cmd_list_element
*unsethistlist
;
135 /* Chain containing all defined maintenance subcommands. */
137 struct cmd_list_element
*maintenancelist
;
139 /* Chain containing all defined "maintenance info" subcommands. */
141 struct cmd_list_element
*maintenanceinfolist
;
143 /* Chain containing all defined "maintenance print" subcommands. */
145 struct cmd_list_element
*maintenanceprintlist
;
147 /* Chain containing all defined "maintenance check" subcommands. */
149 struct cmd_list_element
*maintenancechecklist
;
151 struct cmd_list_element
*setprintlist
;
153 struct cmd_list_element
*showprintlist
;
155 struct cmd_list_element
*setdebuglist
;
157 struct cmd_list_element
*showdebuglist
;
159 struct cmd_list_element
*setchecklist
;
161 struct cmd_list_element
*showchecklist
;
163 /* Command tracing state. */
165 int source_verbose
= 0;
166 int trace_commands
= 0;
168 /* 'script-extension' option support. */
170 static const char script_ext_off
[] = "off";
171 static const char script_ext_soft
[] = "soft";
172 static const char script_ext_strict
[] = "strict";
174 static const char *const script_ext_enums
[] = {
181 static const char *script_ext_mode
= script_ext_soft
;
183 /* Utility used everywhere when at least one argument is needed and
187 error_no_arg (const char *why
)
189 error (_("Argument required (%s)."), why
);
192 /* The "info" command is defined as a prefix, with allow_unknown = 0.
193 Therefore, its own definition is called only for "info" with no
197 info_command (const char *arg
, int from_tty
)
199 printf_unfiltered (_("\"info\" must be followed by "
200 "the name of an info command.\n"));
201 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
204 /* The "show" command with no arguments shows all the settings. */
207 show_command (const char *arg
, int from_tty
)
209 cmd_show_list (showlist
, from_tty
, "");
213 /* Provide documentation on command or list given by COMMAND. FROM_TTY
217 help_command (const char *command
, int from_tty
)
219 help_cmd (command
, gdb_stdout
);
223 /* Note: The "complete" command is used by Emacs to implement completion.
224 [Is that why this function writes output with *_unfiltered?] */
227 complete_command (const char *arg
, int from_tty
)
231 if (max_completions
== 0)
233 /* Only print this for non-mi frontends. An MI frontend may not
234 be able to handle this. */
235 if (!current_uiout
->is_mi_like_p ())
237 printf_unfiltered (_("max-completions is zero,"
238 " completion is disabled.\n"));
246 int quote_char
= '\0';
249 completion_result result
= complete (arg
, &word
, "e_char
);
251 std::string
arg_prefix (arg
, word
- arg
);
253 if (result
.number_matches
!= 0)
255 if (result
.number_matches
== 1)
256 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
259 result
.sort_match_list ();
261 for (size_t i
= 0; i
< result
.number_matches
; i
++)
263 printf_unfiltered ("%s%s",
265 result
.match_list
[i
+ 1]);
267 printf_unfiltered ("%c", quote_char
);
268 printf_unfiltered ("\n");
272 if (result
.number_matches
== max_completions
)
274 /* ARG_PREFIX and WORD are included in the output so that emacs
275 will include the message in the output. */
276 printf_unfiltered (_("%s%s %s\n"),
277 arg_prefix
.c_str (), word
,
278 get_max_completions_reached_message ());
284 is_complete_command (struct cmd_list_element
*c
)
286 return cmd_cfunc_eq (c
, complete_command
);
290 show_version (const char *args
, int from_tty
)
292 print_gdb_version (gdb_stdout
, true);
293 printf_filtered ("\n");
297 show_configuration (const char *args
, int from_tty
)
299 print_gdb_configuration (gdb_stdout
);
302 /* Handle the quit command. */
305 quit_command (const char *args
, int from_tty
)
309 /* An optional expression may be used to cause gdb to terminate with
310 the value of that expression. */
313 struct value
*val
= parse_and_eval (args
);
315 exit_code
= (int) value_as_long (val
);
318 if (!quit_confirm ())
319 error (_("Not confirmed."));
321 query_if_trace_running (from_tty
);
323 quit_force (args
? &exit_code
: NULL
, from_tty
);
327 pwd_command (const char *args
, int from_tty
)
330 error (_("The \"pwd\" command does not take an argument: %s"), args
);
332 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
335 error (_("Error finding name of working directory: %s"),
336 safe_strerror (errno
));
338 if (strcmp (cwd
.get (), current_directory
) != 0)
339 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
340 current_directory
, cwd
.get ());
342 printf_unfiltered (_("Working directory %s.\n"), current_directory
);
346 cd_command (const char *dir
, int from_tty
)
349 /* Found something other than leading repetitions of "/..". */
353 /* If the new directory is absolute, repeat is a no-op; if relative,
354 repeat might be useful but is more likely to be a mistake. */
357 gdb::unique_xmalloc_ptr
<char> dir_holder
358 (tilde_expand (dir
!= NULL
? dir
: "~"));
359 dir
= dir_holder
.get ();
362 perror_with_name (dir
);
364 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
365 /* There's too much mess with DOSish names like "d:", "d:.",
366 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
367 simply get the canonicalized name of the current directory. */
368 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
373 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
375 /* Remove the trailing slash unless this is a root directory
376 (including a drive letter on non-Unix systems). */
377 if (!(len
== 1) /* "/" */
378 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
379 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
385 dir_holder
.reset (savestring (dir
, len
));
386 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
388 xfree (current_directory
);
389 current_directory
= dir_holder
.release ();
393 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
394 current_directory
= concat (current_directory
, dir_holder
.get (),
397 current_directory
= concat (current_directory
, SLASH_STRING
,
398 dir_holder
.get (), (char *) NULL
);
401 /* Now simplify any occurrences of `.' and `..' in the pathname. */
404 for (p
= current_directory
; *p
;)
406 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
407 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
408 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
409 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
410 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
414 /* Search backwards for the directory just before the "/.."
415 and obliterate it and the "/..". */
418 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
421 if (q
== current_directory
)
422 /* current_directory is
423 a relative pathname ("can't happen"--leave it alone). */
427 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
432 /* We are dealing with leading repetitions of "/..", for
433 example "/../..", which is the Mach super-root. */
443 forget_cached_source_info ();
446 pwd_command ((char *) 0, 1);
449 /* Show the current value of the 'script-extension' option. */
452 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
453 struct cmd_list_element
*c
, const char *value
)
455 fprintf_filtered (file
,
456 _("Script filename extension recognition is \"%s\".\n"),
460 /* Try to open SCRIPT_FILE.
461 If successful, the full path name is stored in *FULL_PATHP,
462 and the stream is returned.
463 If not successful, return NULL; errno is set for the last file
466 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
467 search for it in the source search path. */
469 gdb::optional
<open_script
>
470 find_and_open_script (const char *script_file
, int search_path
)
473 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
474 gdb::optional
<open_script
> opened
;
476 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
479 search_flags
|= OPF_SEARCH_IN_PATH
;
481 /* Search for and open 'file' on the search path used for source
482 files. Put the full location in *FULL_PATHP. */
483 gdb::unique_xmalloc_ptr
<char> full_path
;
484 fd
= openp (source_path
, search_flags
,
485 file
.get (), O_RDONLY
, &full_path
);
490 FILE *result
= fdopen (fd
, FOPEN_RT
);
493 int save_errno
= errno
;
499 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
504 /* Load script FILE, which has already been opened as STREAM.
505 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
506 This is provided as FILE may have been found via the source search path.
507 An important thing to note here is that FILE may be a symlink to a file
508 with a different or non-existing suffix, and thus one cannot infer the
509 extension language from FILE_TO_OPEN. */
512 source_script_from_stream (FILE *stream
, const char *file
,
513 const char *file_to_open
)
515 if (script_ext_mode
!= script_ext_off
)
517 const struct extension_language_defn
*extlang
518 = get_ext_lang_of_file (file
);
522 if (ext_lang_present_p (extlang
))
524 script_sourcer_func
*sourcer
525 = ext_lang_script_sourcer (extlang
);
527 gdb_assert (sourcer
!= NULL
);
528 sourcer (extlang
, stream
, file_to_open
);
531 else if (script_ext_mode
== script_ext_soft
)
533 /* Assume the file is a gdb script.
534 This is handled below. */
537 throw_ext_lang_unsupported (extlang
);
541 script_from_file (stream
, file
);
544 /* Worker to perform the "source" command.
546 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
547 search for it in the source search path. */
550 source_script_with_search (const char *file
, int from_tty
, int search_path
)
553 if (file
== NULL
|| *file
== 0)
554 error (_("source command requires file name of file to source."));
556 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
559 /* The script wasn't found, or was otherwise inaccessible.
560 If the source command was invoked interactively, throw an
561 error. Otherwise (e.g. if it was invoked by a script),
562 just emit a warning, rather than cause an error. */
564 perror_with_name (file
);
567 perror_warning_with_name (file
);
572 /* The python support reopens the file, so we need to pass full_path here
573 in case the file was found on the search path. It's useful to do this
574 anyway so that error messages show the actual file used. But only do
575 this if we (may have) used search_path, as printing the full path in
576 errors for the non-search case can be more noise than signal. */
577 source_script_from_stream (opened
->stream
.get (), file
,
578 search_path
? opened
->full_path
.get () : file
);
581 /* Wrapper around source_script_with_search to export it to main.c
582 for use in loading .gdbinit scripts. */
585 source_script (const char *file
, int from_tty
)
587 source_script_with_search (file
, from_tty
, 0);
591 source_command (const char *args
, int from_tty
)
593 const char *file
= args
;
596 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
598 /* -v causes the source command to run in verbose mode.
599 -s causes the file to be searched in the source search path,
600 even if the file name contains a '/'.
601 We still have to be able to handle filenames with spaces in a
602 backward compatible way, so buildargv is not appropriate. */
606 while (args
[0] != '\0')
608 /* Make sure leading white space does not break the
610 args
= skip_spaces (args
);
615 if (args
[1] == 'v' && isspace (args
[2]))
619 /* Skip passed -v. */
622 else if (args
[1] == 's' && isspace (args
[2]))
626 /* Skip passed -s. */
633 file
= skip_spaces (args
);
636 source_script_with_search (file
, from_tty
, search_path
);
641 echo_command (const char *text
, int from_tty
)
643 const char *p
= text
;
647 while ((c
= *p
++) != '\0')
651 /* \ at end of argument is used after spaces
652 so they won't be lost. */
656 c
= parse_escape (get_current_arch (), &p
);
658 printf_filtered ("%c", c
);
661 printf_filtered ("%c", c
);
664 reset_terminal_style (gdb_stdout
);
666 /* Force this output to appear now. */
668 gdb_flush (gdb_stdout
);
672 shell_escape (const char *arg
, int from_tty
)
674 #if defined(CANT_FORK) || \
675 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
676 /* If ARG is NULL, they want an inferior shell, but `system' just
677 reports if the shell is available when passed a NULL arg. */
678 int rc
= system (arg
? arg
: "");
681 arg
= "inferior shell";
684 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
685 safe_strerror (errno
));
687 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
689 /* Make sure to return to the directory GDB thinks it is, in case
690 the shell command we just ran changed it. */
691 chdir (current_directory
);
693 #else /* Can fork. */
696 if ((pid
= vfork ()) == 0)
698 const char *p
, *user_shell
= get_shell ();
702 /* Get the name of the shell for arg0. */
703 p
= lbasename (user_shell
);
706 execl (user_shell
, p
, (char *) 0);
708 execl (user_shell
, p
, "-c", arg
, (char *) 0);
710 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
711 safe_strerror (errno
));
716 waitpid (pid
, &status
, 0);
718 error (_("Fork failed"));
719 #endif /* Can fork. */
722 /* Implementation of the "shell" command. */
725 shell_command (const char *arg
, int from_tty
)
727 shell_escape (arg
, from_tty
);
731 edit_command (const char *arg
, int from_tty
)
733 struct symtab_and_line sal
;
739 /* Pull in the current default source line if necessary. */
742 set_default_source_symtab_and_line ();
743 sal
= get_current_source_symtab_and_line ();
746 /* Bare "edit" edits file with present line. */
751 error (_("No default source file yet."));
752 sal
.line
+= get_lines_to_list () / 2;
758 /* Now should only be one argument -- decode it in SAL. */
760 event_location_up location
= string_to_event_location (&arg1
,
762 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
763 DECODE_LINE_LIST_MODE
,
772 if (sals
.size () > 1)
774 ambiguous_line_spec (sals
,
775 _("Specified line is ambiguous:\n"));
782 error (_("Junk at end of line specification."));
784 /* If line was specified by address, first print exactly which
785 line, and which file. In this case, sal.symtab == 0 means
786 address is outside of all known source files, not that user
787 failed to give a filename. */
790 struct gdbarch
*gdbarch
;
793 error (_("No source file for address %s."),
794 paddress (get_current_arch (), sal
.pc
));
796 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
797 sym
= find_pc_function (sal
.pc
);
799 printf_filtered ("%s is in %s (%s:%d).\n",
800 paddress (gdbarch
, sal
.pc
),
801 SYMBOL_PRINT_NAME (sym
),
802 symtab_to_filename_for_display (sal
.symtab
),
805 printf_filtered ("%s is at %s:%d.\n",
806 paddress (gdbarch
, sal
.pc
),
807 symtab_to_filename_for_display (sal
.symtab
),
811 /* If what was given does not imply a symtab, it must be an
812 undebuggable symbol which means no source code. */
815 error (_("No line number known for %s."), arg
);
818 if ((editor
= getenv ("EDITOR")) == NULL
)
821 fn
= symtab_to_fullname (sal
.symtab
);
823 /* Quote the file name, in case it has whitespace or other special
825 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
826 shell_escape (p
, from_tty
);
831 list_command (const char *arg
, int from_tty
)
841 /* Pull in the current default source line if necessary. */
842 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
844 set_default_source_symtab_and_line ();
845 symtab_and_line cursal
= get_current_source_symtab_and_line ();
847 /* If this is the first "list" since we've set the current
848 source line, center the listing around that line. */
849 if (get_first_line_listed () == 0)
853 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
855 /* A small special case --- if listing backwards, and we
856 should list only one line, list the preceding line,
857 instead of the exact line we've just shown after e.g.,
858 stopping for a breakpoint. */
859 if (arg
!= NULL
&& arg
[0] == '-'
860 && get_lines_to_list () == 1 && first
> 1)
863 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
866 /* "l" or "l +" lists next ten lines. */
867 else if (arg
== NULL
|| arg
[0] == '+')
868 print_source_lines (cursal
.symtab
,
869 source_lines_range (cursal
.line
), 0);
871 /* "l -" lists previous ten lines, the ones before the ten just
873 else if (arg
[0] == '-')
875 if (get_first_line_listed () == 1)
876 error (_("Already at the start of %s."),
877 symtab_to_filename_for_display (cursal
.symtab
));
878 source_lines_range
range (get_first_line_listed (),
879 source_lines_range::BACKWARD
);
880 print_source_lines (cursal
.symtab
, range
, 0);
886 /* Now if there is only one argument, decode it in SAL
888 If there are two arguments, decode them in SAL and SAL_END
889 and clear NO_END; however, if one of the arguments is blank,
890 set DUMMY_BEG or DUMMY_END to record that fact. */
892 if (!have_full_symbols () && !have_partial_symbols ())
893 error (_("No symbol table is loaded. Use the \"file\" command."));
895 std::vector
<symtab_and_line
> sals
;
896 symtab_and_line sal
, sal_end
;
903 event_location_up location
= string_to_event_location (&arg1
,
905 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
917 /* Record whether the BEG arg is all digits. */
919 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
920 linenum_beg
= (p
== arg1
);
922 /* Save the range of the first argument, in case we need to let the
923 user know it was ambiguous. */
924 const char *beg
= arg
;
925 size_t beg_len
= arg1
- beg
;
927 while (*arg1
== ' ' || *arg1
== '\t')
932 if (sals
.size () > 1)
934 ambiguous_line_spec (sals
,
935 _("Specified first line '%.*s' is ambiguous:\n"),
940 while (*arg1
== ' ' || *arg1
== '\t')
946 /* Save the last argument, in case we need to let the user
947 know it was ambiguous. */
948 const char *end_arg
= arg1
;
950 event_location_up location
951 = string_to_event_location (&arg1
, current_language
);
953 std::vector
<symtab_and_line
> sals_end
955 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
957 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
958 NULL
, sal
.symtab
, sal
.line
));
960 filter_sals (sals_end
);
961 if (sals_end
.empty ())
963 if (sals_end
.size () > 1)
965 ambiguous_line_spec (sals_end
,
966 _("Specified last line '%s' is ambiguous:\n"),
970 sal_end
= sals_end
[0];
975 error (_("Junk at end of line specification."));
977 if (!no_end
&& !dummy_beg
&& !dummy_end
978 && sal
.symtab
!= sal_end
.symtab
)
979 error (_("Specified first and last lines are in different files."));
980 if (dummy_beg
&& dummy_end
)
981 error (_("Two empty args do not say what lines to list."));
983 /* If line was specified by address,
984 first print exactly which line, and which file.
986 In this case, sal.symtab == 0 means address is outside of all
987 known source files, not that user failed to give a filename. */
990 struct gdbarch
*gdbarch
;
993 error (_("No source file for address %s."),
994 paddress (get_current_arch (), sal
.pc
));
996 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
997 sym
= find_pc_function (sal
.pc
);
999 printf_filtered ("%s is in %s (%s:%d).\n",
1000 paddress (gdbarch
, sal
.pc
),
1001 SYMBOL_PRINT_NAME (sym
),
1002 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1004 printf_filtered ("%s is at %s:%d.\n",
1005 paddress (gdbarch
, sal
.pc
),
1006 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1009 /* If line was not specified by just a line number, and it does not
1010 imply a symtab, it must be an undebuggable symbol which means no
1013 if (!linenum_beg
&& sal
.symtab
== 0)
1014 error (_("No line number known for %s."), arg
);
1016 /* If this command is repeated with RET,
1017 turn it into the no-arg variant. */
1020 set_repeat_arguments ("");
1022 if (dummy_beg
&& sal_end
.symtab
== 0)
1023 error (_("No default source file yet. Do \"help list\"."));
1026 source_lines_range
range (sal_end
.line
+ 1,
1027 source_lines_range::BACKWARD
);
1028 print_source_lines (sal_end
.symtab
, range
, 0);
1030 else if (sal
.symtab
== 0)
1031 error (_("No default source file yet. Do \"help list\"."));
1034 for (int i
= 0; i
< sals
.size (); i
++)
1037 int first_line
= sal
.line
- get_lines_to_list () / 2;
1040 if (sals
.size () > 1)
1041 print_sal_location (sal
);
1042 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1046 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1048 print_source_lines (sal
.symtab
,
1049 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1053 /* Subroutine of disassemble_command to simplify it.
1054 Perform the disassembly.
1055 NAME is the name of the function if known, or NULL.
1056 [LOW,HIGH) are the range of addresses to disassemble.
1057 BLOCK is the block to disassemble; it needs to be provided
1058 when non-contiguous blocks are disassembled; otherwise
1060 MIXED is non-zero to print source with the assembler. */
1063 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1064 CORE_ADDR low
, CORE_ADDR high
,
1065 const struct block
*block
,
1066 gdb_disassembly_flags flags
)
1069 if (!tui_is_window_visible (DISASSEM_WIN
))
1072 printf_filtered ("Dump of assembler code ");
1074 printf_filtered ("for function %s:\n", name
);
1075 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1078 printf_filtered ("from %s to %s:\n",
1079 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1081 /* Dump the specified range. */
1082 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1086 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1088 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1089 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1090 printf_filtered (_("Address range %s to %s:\n"),
1091 paddress (gdbarch
, range_low
),
1092 paddress (gdbarch
, range_high
));
1093 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1094 range_low
, range_high
);
1097 printf_filtered ("End of assembler dump.\n");
1102 tui_show_assembly (gdbarch
, low
);
1107 /* Subroutine of disassemble_command to simplify it.
1108 Print a disassembly of the current function according to FLAGS. */
1111 disassemble_current_function (gdb_disassembly_flags flags
)
1113 struct frame_info
*frame
;
1114 struct gdbarch
*gdbarch
;
1115 CORE_ADDR low
, high
, pc
;
1117 const struct block
*block
;
1119 frame
= get_selected_frame (_("No frame selected."));
1120 gdbarch
= get_frame_arch (frame
);
1121 pc
= get_frame_address_in_block (frame
);
1122 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1123 error (_("No function contains program counter for selected frame."));
1125 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1128 /* FIXME: cagney/2004-02-07: This should be an observer. */
1129 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1131 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1133 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1136 /* Dump a specified section of assembly code.
1140 - dump the assembly code for the function of the current pc
1141 disassemble [/mrs] addr
1142 - dump the assembly code for the function at ADDR
1143 disassemble [/mrs] low,high
1144 disassemble [/mrs] low,+length
1145 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1147 A /m modifier will include source code with the assembly in a
1148 "source centric" view. This view lists only the file of the first insn,
1149 even if other source files are involved (e.g., inlined functions), and
1150 the output is in source order, even with optimized code. This view is
1151 considered deprecated as it hasn't been useful in practice.
1153 A /r modifier will include raw instructions in hex with the assembly.
1155 A /s modifier will include source code with the assembly, like /m, with
1156 two important differences:
1157 1) The output is still in pc address order.
1158 2) File names and contents for all relevant source files are displayed. */
1161 disassemble_command (const char *arg
, int from_tty
)
1163 struct gdbarch
*gdbarch
= get_current_arch ();
1164 CORE_ADDR low
, high
;
1167 gdb_disassembly_flags flags
;
1169 const struct block
*block
= nullptr;
1180 error (_("Missing modifier."));
1182 while (*p
&& ! isspace (*p
))
1187 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1190 flags
|= DISASSEMBLY_RAW_INSN
;
1193 flags
|= DISASSEMBLY_SOURCE
;
1196 error (_("Invalid disassembly modifier."));
1200 p
= skip_spaces (p
);
1203 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1204 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1205 error (_("Cannot specify both /m and /s."));
1209 flags
|= DISASSEMBLY_OMIT_FNAME
;
1210 disassemble_current_function (flags
);
1214 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1220 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1221 error (_("No function contains specified address."));
1223 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1226 /* FIXME: cagney/2004-02-07: This should be an observer. */
1227 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1229 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1230 flags
|= DISASSEMBLY_OMIT_FNAME
;
1234 /* Two arguments. */
1237 p
= skip_spaces (p
);
1243 high
= parse_and_eval_address (p
);
1248 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1252 make_command (const char *arg
, int from_tty
)
1255 shell_escape ("make", from_tty
);
1258 std::string cmd
= std::string ("make ") + arg
;
1260 shell_escape (cmd
.c_str (), from_tty
);
1265 show_user (const char *args
, int from_tty
)
1267 struct cmd_list_element
*c
;
1268 extern struct cmd_list_element
*cmdlist
;
1272 const char *comname
= args
;
1274 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1275 if (!cli_user_command_p (c
))
1276 error (_("Not a user command."));
1277 show_user_1 (c
, "", args
, gdb_stdout
);
1281 for (c
= cmdlist
; c
; c
= c
->next
)
1283 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1284 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1289 /* Search through names of commands and documentations for a certain
1290 regular expression. */
1293 apropos_command (const char *searchstr
, int from_tty
)
1295 if (searchstr
== NULL
)
1296 error (_("REGEXP string is empty"));
1298 compiled_regex
pattern (searchstr
, REG_ICASE
,
1299 _("Error in regular expression"));
1301 apropos_cmd (gdb_stdout
, cmdlist
, pattern
, "");
1304 /* Subroutine of alias_command to simplify it.
1305 Return the first N elements of ARGV flattened back to a string
1306 with a space separating each element.
1307 ARGV may not be NULL.
1308 This does not take care of quoting elements in case they contain spaces
1312 argv_to_string (char **argv
, int n
)
1317 gdb_assert (argv
!= NULL
);
1318 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1320 for (i
= 0; i
< n
; ++i
)
1330 /* Subroutine of alias_command to simplify it.
1331 Return true if COMMAND exists, unambiguously. Otherwise false. */
1334 valid_command_p (const char *command
)
1336 struct cmd_list_element
*c
;
1338 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1340 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1343 /* This is the slightly tricky part.
1344 lookup_cmd_1 will return a pointer to the last part of COMMAND
1345 to match, leaving COMMAND pointing at the remainder. */
1346 while (*command
== ' ' || *command
== '\t')
1348 return *command
== '\0';
1351 /* Called when "alias" was incorrectly used. */
1354 alias_usage_error (void)
1356 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1359 /* Make an alias of an existing command. */
1362 alias_command (const char *args
, int from_tty
)
1364 int i
, alias_argc
, command_argc
;
1365 int abbrev_flag
= 0;
1367 const char *alias
, *command
;
1369 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1370 alias_usage_error ();
1372 equals
= strchr (args
, '=');
1373 std::string
args2 (args
, equals
- args
);
1375 gdb_argv
built_alias_argv (args2
.c_str ());
1376 gdb_argv
command_argv (equals
+ 1);
1378 char **alias_argv
= built_alias_argv
.get ();
1379 while (alias_argv
[0] != NULL
)
1381 if (strcmp (alias_argv
[0], "-a") == 0)
1386 else if (strcmp (alias_argv
[0], "--") == 0)
1395 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1396 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1397 alias_usage_error ();
1399 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1401 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1404 error (_("Invalid command name: %s"), alias_argv
[i
]);
1406 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1410 alias_argc
= countargv (alias_argv
);
1411 command_argc
= command_argv
.count ();
1413 /* COMMAND must exist.
1414 Reconstruct the command to remove any extraneous spaces,
1415 for better error messages. */
1416 std::string
command_string (argv_to_string (command_argv
.get (),
1418 command
= command_string
.c_str ();
1419 if (! valid_command_p (command
))
1420 error (_("Invalid command to alias to: %s"), command
);
1422 /* ALIAS must not exist. */
1423 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1424 alias
= alias_string
.c_str ();
1425 if (valid_command_p (alias
))
1426 error (_("Alias already exists: %s"), alias
);
1428 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1429 Example: alias spe = set print elements
1431 Otherwise ALIAS and COMMAND must have the same number of words,
1432 and every word except the last must match; and the last word of
1433 ALIAS is made an alias of the last word of COMMAND.
1434 Example: alias set print elms = set pr elem
1435 Note that unambiguous abbreviations are allowed. */
1437 if (alias_argc
== 1)
1439 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1440 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1445 const char *alias_prefix
, *command_prefix
;
1446 struct cmd_list_element
*c_alias
, *c_command
;
1448 if (alias_argc
!= command_argc
)
1449 error (_("Mismatched command length between ALIAS and COMMAND."));
1451 /* Create copies of ALIAS and COMMAND without the last word,
1452 and use that to verify the leading elements match. */
1453 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1455 std::string
command_prefix_string (argv_to_string (alias_argv
,
1457 alias_prefix
= alias_prefix_string
.c_str ();
1458 command_prefix
= command_prefix_string
.c_str ();
1460 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1461 /* We've already tried to look up COMMAND. */
1462 gdb_assert (c_command
!= NULL
1463 && c_command
!= (struct cmd_list_element
*) -1);
1464 gdb_assert (c_command
->prefixlist
!= NULL
);
1465 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1466 if (c_alias
!= c_command
)
1467 error (_("ALIAS and COMMAND prefixes do not match."));
1469 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1470 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1471 command_argv
[command_argc
- 1],
1472 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1476 /* Print the file / line number / symbol name of the location
1477 specified by SAL. */
1480 print_sal_location (const symtab_and_line
&sal
)
1482 scoped_restore_current_program_space restore_pspace
;
1483 set_current_program_space (sal
.pspace
);
1485 const char *sym_name
= NULL
;
1486 if (sal
.symbol
!= NULL
)
1487 sym_name
= SYMBOL_PRINT_NAME (sal
.symbol
);
1488 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1489 symtab_to_filename_for_display (sal
.symtab
),
1490 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1493 /* Print a list of files and line numbers which a user may choose from
1494 in order to list a function which was specified ambiguously (as
1495 with `list classname::overloadedfuncname', for example). The SALS
1496 array provides the filenames and line numbers. FORMAT is a
1497 printf-style format string used to tell the user what was
1501 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1502 const char *format
, ...)
1505 va_start (ap
, format
);
1506 vprintf_filtered (format
, ap
);
1509 for (const auto &sal
: sals
)
1510 print_sal_location (sal
);
1513 /* Comparison function for filter_sals. Returns a qsort-style
1517 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1519 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1520 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1528 else if (dirb
== NULL
)
1535 r
= filename_cmp (dira
, dirb
);
1540 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1544 if (sala
.line
< salb
.line
)
1546 return sala
.line
== salb
.line
? 0 : 1;
1549 /* Remove any SALs that do not match the current program space, or
1550 which appear to be "file:line" duplicates. */
1553 filter_sals (std::vector
<symtab_and_line
> &sals
)
1555 /* Remove SALs that do not match. */
1556 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1557 [&] (const symtab_and_line
&sal
)
1558 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1561 std::sort (sals
.begin (), from
,
1562 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1563 { return cmp_symtabs (sala
, salb
) < 0; });
1565 from
= std::unique (sals
.begin (), from
,
1566 [&] (const symtab_and_line
&sala
,
1567 const symtab_and_line
&salb
)
1568 { return cmp_symtabs (sala
, salb
) == 0; });
1570 sals
.erase (from
, sals
.end ());
1574 set_debug (const char *arg
, int from_tty
)
1576 printf_unfiltered (_("\"set debug\" must be followed by "
1577 "the name of a debug subcommand.\n"));
1578 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1582 show_debug (const char *args
, int from_tty
)
1584 cmd_show_list (showdebuglist
, from_tty
, "");
1588 init_cmd_lists (void)
1590 max_user_call_depth
= 1024;
1594 show_info_verbose (struct ui_file
*file
, int from_tty
,
1595 struct cmd_list_element
*c
,
1599 fprintf_filtered (file
,
1600 _("Verbose printing of informational messages is %s.\n"),
1603 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1607 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1608 struct cmd_list_element
*c
, const char *value
)
1610 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1615 show_remote_debug (struct ui_file
*file
, int from_tty
,
1616 struct cmd_list_element
*c
, const char *value
)
1618 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1623 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1624 struct cmd_list_element
*c
, const char *value
)
1626 fprintf_filtered (file
,
1627 _("Timeout limit to wait for target to respond is %s.\n"),
1632 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1633 struct cmd_list_element
*c
, const char *value
)
1635 fprintf_filtered (file
,
1636 _("The max call depth for user-defined commands is %s.\n"),
1641 _initialize_cli_cmds (void)
1643 struct cmd_list_element
*c
;
1645 /* Define the classes of commands.
1646 They will appear in the help list in alphabetical order. */
1648 add_cmd ("internals", class_maintenance
, _("\
1649 Maintenance commands.\n\
1650 Some gdb commands are provided just for use by gdb maintainers.\n\
1651 These commands are subject to frequent change, and may not be as\n\
1652 well documented as user commands."),
1654 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
1655 add_cmd ("aliases", class_alias
,
1656 _("Aliases of other commands."), &cmdlist
);
1657 add_cmd ("user-defined", class_user
, _("\
1658 User-defined commands.\n\
1659 The commands in this class are those defined by the user.\n\
1660 Use the \"define\" command to define a command."), &cmdlist
);
1661 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
1663 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
1664 add_cmd ("files", class_files
, _("Specifying and examining files."),
1666 add_cmd ("breakpoints", class_breakpoint
,
1667 _("Making program stop at certain points."), &cmdlist
);
1668 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
1669 add_cmd ("stack", class_stack
, _("\
1670 Examining the stack.\n\
1671 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1672 counting from zero for the innermost (currently executing) frame.\n\n\
1673 At any time gdb identifies one frame as the \"selected\" frame.\n\
1674 Variable lookups are done with respect to the selected frame.\n\
1675 When the program being debugged stops, gdb selects the innermost frame.\n\
1676 The commands below can be used to select other frames by number or address."),
1678 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
1680 /* Define general commands. */
1682 add_com ("pwd", class_files
, pwd_command
, _("\
1683 Print working directory. This is used for your program as well."));
1685 c
= add_cmd ("cd", class_files
, cd_command
, _("\
1686 Set working directory to DIR for debugger.\n\
1687 The debugger's current working directory specifies where scripts and other\n\
1688 files that can be loaded by GDB are located.\n\
1689 In order to change the inferior's current working directory, the recommended\n\
1690 way is to use the \"set cwd\" command."), &cmdlist
);
1691 set_cmd_completer (c
, filename_completer
);
1693 add_com ("echo", class_support
, echo_command
, _("\
1694 Print a constant string. Give string as argument.\n\
1695 C escape sequences may be used in the argument.\n\
1696 No newline is added at the end of the argument;\n\
1697 use \"\\n\" if you want a newline to be printed.\n\
1698 Since leading and trailing whitespace are ignored in command arguments,\n\
1699 if you want to print some you must use \"\\\" before leading whitespace\n\
1700 to be printed or after trailing whitespace."));
1702 add_setshow_enum_cmd ("script-extension", class_support
,
1703 script_ext_enums
, &script_ext_mode
, _("\
1704 Set mode for script filename extension recognition."), _("\
1705 Show mode for script filename extension recognition."), _("\
1706 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1707 soft == evaluate script according to filename extension, fallback to GDB script"
1709 strict == evaluate script according to filename extension, error if not supported"
1712 show_script_ext_mode
,
1713 &setlist
, &showlist
);
1715 add_com ("quit", class_support
, quit_command
, _("\
1717 Usage: quit [EXPR]\n\
1718 The optional expression EXPR, if present, is evaluated and the result\n\
1719 used as GDB's exit code. The default is zero."));
1720 c
= add_com ("help", class_support
, help_command
,
1721 _("Print list of commands."));
1722 set_cmd_completer (c
, command_completer
);
1723 add_com_alias ("q", "quit", class_support
, 1);
1724 add_com_alias ("h", "help", class_support
, 1);
1726 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
1727 Set verbosity."), _("\
1728 Show verbosity."), NULL
,
1731 &setlist
, &showlist
);
1733 add_prefix_cmd ("history", class_support
, set_history
,
1734 _("Generic command for setting command history parameters."),
1735 &sethistlist
, "set history ", 0, &setlist
);
1736 add_prefix_cmd ("history", class_support
, show_history
,
1737 _("Generic command for showing command history parameters."),
1738 &showhistlist
, "show history ", 0, &showlist
);
1740 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
1741 Set history expansion on command input."), _("\
1742 Show history expansion on command input."), _("\
1743 Without an argument, history expansion is enabled."),
1745 show_history_expansion_p
,
1746 &sethistlist
, &showhistlist
);
1748 add_prefix_cmd ("info", class_info
, info_command
, _("\
1749 Generic command for showing things about the program being debugged."),
1750 &infolist
, "info ", 0, &cmdlist
);
1751 add_com_alias ("i", "info", class_info
, 1);
1752 add_com_alias ("inf", "info", class_info
, 1);
1754 add_com ("complete", class_obscure
, complete_command
,
1755 _("List the completions for the rest of the line as a command."));
1757 add_prefix_cmd ("show", class_info
, show_command
, _("\
1758 Generic command for showing things about the debugger."),
1759 &showlist
, "show ", 0, &cmdlist
);
1760 /* Another way to get at the same thing. */
1761 add_info ("set", show_command
, _("Show all GDB settings."));
1763 add_cmd ("commands", no_set_class
, show_commands
, _("\
1764 Show the history of commands you typed.\n\
1765 You can supply a command number to start with, or a `+' to start after\n\
1766 the previous command number shown."),
1769 add_cmd ("version", no_set_class
, show_version
,
1770 _("Show what version of GDB this is."), &showlist
);
1772 add_cmd ("configuration", no_set_class
, show_configuration
,
1773 _("Show how GDB was configured at build time."), &showlist
);
1775 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
1776 Set debugging of remote protocol."), _("\
1777 Show debugging of remote protocol."), _("\
1778 When enabled, each packet sent or received with the remote target\n\
1782 &setdebuglist
, &showdebuglist
);
1784 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
1785 &remote_timeout
, _("\
1786 Set timeout limit to wait for target to respond."), _("\
1787 Show timeout limit to wait for target to respond."), _("\
1788 This value is used to set the time limit for gdb to wait for a response\n\
1791 show_remote_timeout
,
1792 &setlist
, &showlist
);
1794 add_prefix_cmd ("debug", no_class
, set_debug
,
1795 _("Generic command for setting gdb debugging flags"),
1796 &setdebuglist
, "set debug ", 0, &setlist
);
1798 add_prefix_cmd ("debug", no_class
, show_debug
,
1799 _("Generic command for showing gdb debugging flags"),
1800 &showdebuglist
, "show debug ", 0, &showlist
);
1802 c
= add_com ("shell", class_support
, shell_command
, _("\
1803 Execute the rest of the line as a shell command.\n\
1804 With no arguments, run an inferior shell."));
1805 set_cmd_completer (c
, filename_completer
);
1807 add_com_alias ("!", "shell", class_support
, 0);
1809 c
= add_com ("edit", class_files
, edit_command
, _("\
1810 Edit specified file or function.\n\
1811 With no argument, edits file containing most recent line listed.\n\
1812 Editing targets can be specified in these ways:\n\
1813 FILE:LINENUM, to edit at that line in that file,\n\
1814 FUNCTION, to edit at the beginning of that function,\n\
1815 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1816 *ADDRESS, to edit at the line containing that address.\n\
1817 Uses EDITOR environment variable contents as editor (or ex as default)."));
1819 c
->completer
= location_completer
;
1821 add_com ("list", class_files
, list_command
, _("\
1822 List specified function or line.\n\
1823 With no argument, lists ten more lines after or around previous listing.\n\
1824 \"list -\" lists the ten lines before a previous ten-line listing.\n\
1825 One argument specifies a line, and ten lines are listed around that line.\n\
1826 Two arguments with comma between specify starting and ending lines to list.\n\
1827 Lines can be specified in these ways:\n\
1828 LINENUM, to list around that line in current file,\n\
1829 FILE:LINENUM, to list around that line in that file,\n\
1830 FUNCTION, to list around beginning of that function,\n\
1831 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1832 *ADDRESS, to list around the line containing that address.\n\
1833 With two args, if one is empty, it stands for ten lines away from\n\
1836 By default, when a single location is given, display ten lines.\n\
1837 This can be changed using \"set listsize\", and the current value\n\
1838 can be shown using \"show listsize\"."));
1840 add_com_alias ("l", "list", class_files
, 1);
1843 add_com_alias ("file", "list", class_files
, 1);
1845 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
1846 Disassemble a specified section of memory.\n\
1847 Default is the function surrounding the pc of the selected frame.\n\
1849 With a /m modifier, source lines are included (if available).\n\
1850 This view is \"source centric\": the output is in source line order,\n\
1851 regardless of any optimization that is present. Only the main source file\n\
1852 is displayed, not those of, e.g., any inlined functions.\n\
1853 This modifier hasn't proved useful in practice and is deprecated\n\
1856 With a /s modifier, source lines are included (if available).\n\
1857 This differs from /m in two important respects:\n\
1858 - the output is still in pc address order, and\n\
1859 - file names and contents for all relevant source files are displayed.\n\
1861 With a /r modifier, raw instructions in hex are included.\n\
1863 With a single argument, the function surrounding that address is dumped.\n\
1864 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
1865 in the form of \"start,end\", or \"start,+length\".\n\
1867 Note that the address is interpreted as an expression, not as a location\n\
1868 like in the \"break\" command.\n\
1869 So, for example, if you want to disassemble function bar in file foo.c\n\
1870 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
1871 set_cmd_completer (c
, location_completer
);
1873 c
= add_com ("make", class_support
, make_command
, _("\
1874 Run the ``make'' program using the rest of the line as arguments."));
1875 set_cmd_completer (c
, filename_completer
);
1876 add_cmd ("user", no_class
, show_user
, _("\
1877 Show definitions of non-python/scheme user defined commands.\n\
1878 Argument is the name of the user defined command.\n\
1879 With no argument, show definitions of all user defined commands."), &showlist
);
1880 add_com ("apropos", class_support
, apropos_command
,
1881 _("Search for commands matching a REGEXP"));
1883 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
1884 &max_user_call_depth
, _("\
1885 Set the max call depth for non-python/scheme user-defined commands."), _("\
1886 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
1888 show_max_user_call_depth
,
1889 &setlist
, &showlist
);
1891 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
1892 Set tracing of GDB CLI commands."), _("\
1893 Show state of GDB CLI command tracing."), _("\
1894 When 'on', each command is displayed as it is executed."),
1897 &setlist
, &showlist
);
1899 c
= add_com ("alias", class_support
, alias_command
, _("\
1900 Define a new command that is an alias of an existing command.\n\
1901 Usage: alias [-a] [--] ALIAS = COMMAND\n\
1902 ALIAS is the name of the alias command to create.\n\
1903 COMMAND is the command being aliased to.\n\
1904 If \"-a\" is specified, the command is an abbreviation,\n\
1905 and will not appear in help command list output.\n\
1908 Make \"spe\" an alias of \"set print elements\":\n\
1909 alias spe = set print elements\n\
1910 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
1911 alias -a set print elms = set print elements"));
1915 init_cli_cmds (void)
1917 struct cmd_list_element
*c
;
1918 char *source_help_text
;
1920 source_help_text
= xstrprintf (_("\
1921 Read commands from a file named FILE.\n\
1923 Usage: source [-s] [-v] FILE\n\
1924 -s: search for the script in the source search path,\n\
1925 even if FILE contains directories.\n\
1926 -v: each command in FILE is echoed as it is executed.\n\
1928 Note that the file \"%s\" is read automatically in this way\n\
1929 when GDB is started."), gdbinit
);
1930 c
= add_cmd ("source", class_support
, source_command
,
1931 source_help_text
, &cmdlist
);
1932 set_cmd_completer (c
, filename_completer
);