3 Copyright (C) 2000-2021 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/tilde.h"
23 #include "completer.h"
24 #include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
25 #include "gdbsupport/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 "gdbsupport/filestuff.h"
47 #include "cli/cli-decode.h"
48 #include "cli/cli-script.h"
49 #include "cli/cli-setshow.h"
50 #include "cli/cli-cmds.h"
51 #include "cli/cli-style.h"
52 #include "cli/cli-utils.h"
53 #include "cli/cli-style.h"
55 #include "extension.h"
56 #include "gdbsupport/pathstuff.h"
57 #include "gdbsupport/gdb_tilde_expand.h"
60 #include "tui/tui.h" /* For tui_active et.al. */
67 /* Prototypes for local utility functions */
69 static void print_sal_location (const symtab_and_line
&sal
);
71 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
72 const char *format
, ...)
73 ATTRIBUTE_PRINTF (2, 3);
75 static void filter_sals (std::vector
<symtab_and_line
> &);
79 unsigned int max_user_call_depth
;
81 /* Define all cmd_list_elements. */
83 /* Chain containing all defined commands. */
85 struct cmd_list_element
*cmdlist
;
87 /* Chain containing all defined info subcommands. */
89 struct cmd_list_element
*infolist
;
91 /* Chain containing all defined enable subcommands. */
93 struct cmd_list_element
*enablelist
;
95 /* Chain containing all defined disable subcommands. */
97 struct cmd_list_element
*disablelist
;
99 /* Chain containing all defined stop subcommands. */
101 struct cmd_list_element
*stoplist
;
103 /* Chain containing all defined delete subcommands. */
105 struct cmd_list_element
*deletelist
;
107 /* Chain containing all defined detach subcommands. */
109 struct cmd_list_element
*detachlist
;
111 /* Chain containing all defined kill subcommands. */
113 struct cmd_list_element
*killlist
;
115 /* Chain containing all defined set subcommands */
117 struct cmd_list_element
*setlist
;
119 /* Chain containing all defined unset subcommands */
121 struct cmd_list_element
*unsetlist
;
123 /* Chain containing all defined show subcommands. */
125 struct cmd_list_element
*showlist
;
127 /* Chain containing all defined \"set history\". */
129 struct cmd_list_element
*sethistlist
;
131 /* Chain containing all defined \"show history\". */
133 struct cmd_list_element
*showhistlist
;
135 /* Chain containing all defined \"unset history\". */
137 struct cmd_list_element
*unsethistlist
;
139 /* Chain containing all defined maintenance subcommands. */
141 struct cmd_list_element
*maintenancelist
;
143 /* Chain containing all defined "maintenance info" subcommands. */
145 struct cmd_list_element
*maintenanceinfolist
;
147 /* Chain containing all defined "maintenance print" subcommands. */
149 struct cmd_list_element
*maintenanceprintlist
;
151 /* Chain containing all defined "maintenance check" subcommands. */
153 struct cmd_list_element
*maintenancechecklist
;
155 /* Chain containing all defined "maintenance flush" subcommands. */
157 struct cmd_list_element
*maintenanceflushlist
;
159 struct cmd_list_element
*setprintlist
;
161 struct cmd_list_element
*showprintlist
;
163 struct cmd_list_element
*setdebuglist
;
165 struct cmd_list_element
*showdebuglist
;
167 struct cmd_list_element
*setchecklist
;
169 struct cmd_list_element
*showchecklist
;
171 struct cmd_list_element
*setsourcelist
;
173 struct cmd_list_element
*showsourcelist
;
175 /* Command tracing state. */
177 int source_verbose
= 0;
178 bool trace_commands
= false;
180 /* 'script-extension' option support. */
182 static const char script_ext_off
[] = "off";
183 static const char script_ext_soft
[] = "soft";
184 static const char script_ext_strict
[] = "strict";
186 static const char *const script_ext_enums
[] = {
193 static const char *script_ext_mode
= script_ext_soft
;
195 /* Utility used everywhere when at least one argument is needed and
199 error_no_arg (const char *why
)
201 error (_("Argument required (%s)."), why
);
204 /* This implements the "info" prefix command. Normally such commands
205 are automatically handled by add_basic_prefix_cmd, but in this case
206 a separate command is used so that it can be hooked into by
210 info_command (const char *arg
, int from_tty
)
212 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
215 /* See cli/cli-cmds.h. */
218 with_command_1 (const char *set_cmd_prefix
,
219 cmd_list_element
*setlist
, const char *args
, int from_tty
)
222 error (_("Missing arguments."));
224 const char *delim
= strstr (args
, "--");
225 const char *nested_cmd
= nullptr;
228 error (_("Missing setting before '--' delimiter"));
230 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
231 nested_cmd
= repeat_previous ();
233 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
235 /*allow_unknown=*/ 0,
236 /*ignore_help_classes=*/ 1);
237 gdb_assert (set_cmd
!= nullptr);
239 if (!set_cmd
->var
.has_value ())
240 error (_("Cannot use this setting with the \"with\" command"));
242 std::string temp_value
243 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
245 if (nested_cmd
== nullptr)
246 nested_cmd
= skip_spaces (delim
+ 2);
248 gdb_assert (set_cmd
->var
.has_value ());
249 std::string org_value
= get_setshow_command_value_string (*set_cmd
->var
);
251 /* Tweak the setting to the new temporary value. */
252 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
256 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
258 /* Execute the nested command. */
259 execute_command (nested_cmd
, from_tty
);
261 catch (const gdb_exception
&ex
)
263 /* Restore the setting and rethrow. If restoring the setting
264 throws, swallow the new exception and warn. There's nothing
265 else we can reasonably do. */
268 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
270 catch (const gdb_exception
&ex2
)
272 warning (_("Couldn't restore setting: %s"), ex2
.what ());
278 /* Restore the setting. */
279 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
282 /* See cli/cli-cmds.h. */
285 with_command_completer_1 (const char *set_cmd_prefix
,
286 completion_tracker
&tracker
,
289 tracker
.set_use_custom_word_point (true);
291 const char *delim
= strstr (text
, "--");
293 /* If we're still not past the "--" delimiter, complete the "with"
294 command as if it was a "set" command. */
297 || !isspace (delim
[-1])
298 || !(isspace (delim
[2]) || delim
[2] == '\0'))
300 std::string new_text
= std::string (set_cmd_prefix
) + text
;
301 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
302 complete_nested_command_line (tracker
, new_text
.c_str ());
306 /* We're past the "--" delimiter. Complete on the sub command. */
307 const char *nested_cmd
= skip_spaces (delim
+ 2);
308 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
309 complete_nested_command_line (tracker
, nested_cmd
);
312 /* The "with" command. */
315 with_command (const char *args
, int from_tty
)
317 with_command_1 ("set ", setlist
, args
, from_tty
);
320 /* "with" command completer. */
323 with_command_completer (struct cmd_list_element
*ignore
,
324 completion_tracker
&tracker
,
325 const char *text
, const char * /*word*/)
327 with_command_completer_1 ("set ", tracker
, text
);
330 /* Look up the contents of TEXT as a command usable with default args.
331 Throws an error if no such command is found.
332 Return the found command and advances TEXT past the found command.
333 If the found command is a postfix command, set *PREFIX_CMD to its
336 static struct cmd_list_element
*
337 lookup_cmd_for_default_args (const char **text
,
338 struct cmd_list_element
**prefix_cmd
)
340 const char *orig_text
= *text
;
341 struct cmd_list_element
*lcmd
;
343 if (*text
== nullptr || skip_spaces (*text
) == nullptr)
344 error (_("ALIAS missing."));
346 /* We first use lookup_cmd to verify TEXT unambiguously identifies
348 lcmd
= lookup_cmd (text
, cmdlist
, "", NULL
,
349 /*allow_unknown=*/ 0,
350 /*ignore_help_classes=*/ 1);
352 /* Note that we accept default args for prefix commands,
353 as a prefix command can also be a valid usable
354 command accepting some arguments.
355 For example, "thread apply" applies a command to a
356 list of thread ids, and is also the prefix command for
359 /* We have an unambiguous command for which default args
360 can be specified. What remains after having found LCMD
361 is either spaces, or the default args character. */
363 /* We then use lookup_cmd_composition to detect if the user
364 has specified an alias, and find the possible prefix_cmd
366 struct cmd_list_element
*alias
, *cmd
;
367 lookup_cmd_composition
368 (std::string (orig_text
, *text
- orig_text
).c_str (),
369 &alias
, prefix_cmd
, &cmd
);
370 gdb_assert (cmd
!= nullptr);
371 gdb_assert (cmd
== lcmd
);
372 if (alias
!= nullptr)
378 /* Provide documentation on command or list given by COMMAND. FROM_TTY
382 help_command (const char *command
, int from_tty
)
384 help_cmd (command
, gdb_stdout
);
388 /* Note: The "complete" command is used by Emacs to implement completion.
389 [Is that why this function writes output with *_unfiltered?] */
392 complete_command (const char *arg
, int from_tty
)
396 if (max_completions
== 0)
398 /* Only print this for non-mi frontends. An MI frontend may not
399 be able to handle this. */
400 if (!current_uiout
->is_mi_like_p ())
402 printf_unfiltered (_("max-completions is zero,"
403 " completion is disabled.\n"));
411 int quote_char
= '\0';
414 completion_result result
= complete (arg
, &word
, "e_char
);
416 if (result
.number_matches
!= 0)
418 std::string
arg_prefix (arg
, word
- arg
);
420 if (result
.number_matches
== 1)
421 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
424 result
.sort_match_list ();
426 for (size_t i
= 0; i
< result
.number_matches
; i
++)
428 printf_unfiltered ("%s%s",
430 result
.match_list
[i
+ 1]);
432 printf_unfiltered ("%c", quote_char
);
433 printf_unfiltered ("\n");
437 if (result
.number_matches
== max_completions
)
439 /* ARG_PREFIX and WORD are included in the output so that emacs
440 will include the message in the output. */
441 printf_unfiltered (_("%s%s %s\n"),
442 arg_prefix
.c_str (), word
,
443 get_max_completions_reached_message ());
449 is_complete_command (struct cmd_list_element
*c
)
451 return cmd_simple_func_eq (c
, complete_command
);
455 show_version (const char *args
, int from_tty
)
457 print_gdb_version (gdb_stdout
, true);
458 printf_filtered ("\n");
462 show_configuration (const char *args
, int from_tty
)
464 print_gdb_configuration (gdb_stdout
);
467 /* Handle the quit command. */
470 quit_command (const char *args
, int from_tty
)
474 /* An optional expression may be used to cause gdb to terminate with
475 the value of that expression. */
478 struct value
*val
= parse_and_eval (args
);
480 exit_code
= (int) value_as_long (val
);
483 if (!quit_confirm ())
484 error (_("Not confirmed."));
486 query_if_trace_running (from_tty
);
488 quit_force (args
? &exit_code
: NULL
, from_tty
);
492 pwd_command (const char *args
, int from_tty
)
495 error (_("The \"pwd\" command does not take an argument: %s"), args
);
497 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
500 error (_("Error finding name of working directory: %s"),
501 safe_strerror (errno
));
503 if (strcmp (cwd
.get (), current_directory
) != 0)
504 printf_unfiltered (_("Working directory %ps\n (canonically %ps).\n"),
505 styled_string (file_name_style
.style (),
507 styled_string (file_name_style
.style (), cwd
.get ()));
509 printf_unfiltered (_("Working directory %ps.\n"),
510 styled_string (file_name_style
.style (),
515 cd_command (const char *dir
, int from_tty
)
518 /* Found something other than leading repetitions of "/..". */
522 /* If the new directory is absolute, repeat is a no-op; if relative,
523 repeat might be useful but is more likely to be a mistake. */
526 gdb::unique_xmalloc_ptr
<char> dir_holder
527 (tilde_expand (dir
!= NULL
? dir
: "~"));
528 dir
= dir_holder
.get ();
531 perror_with_name (dir
);
533 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
534 /* There's too much mess with DOSish names like "d:", "d:.",
535 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
536 simply get the canonicalized name of the current directory. */
537 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
542 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
544 /* Remove the trailing slash unless this is a root directory
545 (including a drive letter on non-Unix systems). */
546 if (!(len
== 1) /* "/" */
547 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
548 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
554 dir_holder
.reset (savestring (dir
, len
));
555 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
557 xfree (current_directory
);
558 current_directory
= dir_holder
.release ();
562 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
563 current_directory
= concat (current_directory
, dir_holder
.get (),
566 current_directory
= concat (current_directory
, SLASH_STRING
,
567 dir_holder
.get (), (char *) NULL
);
570 /* Now simplify any occurrences of `.' and `..' in the pathname. */
573 for (p
= current_directory
; *p
;)
575 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
576 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
577 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
578 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
579 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
583 /* Search backwards for the directory just before the "/.."
584 and obliterate it and the "/..". */
587 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
590 if (q
== current_directory
)
591 /* current_directory is
592 a relative pathname ("can't happen"--leave it alone). */
596 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
601 /* We are dealing with leading repetitions of "/..", for
602 example "/../..", which is the Mach super-root. */
612 forget_cached_source_info ();
615 pwd_command ((char *) 0, 1);
618 /* Show the current value of the 'script-extension' option. */
621 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
622 struct cmd_list_element
*c
, const char *value
)
624 fprintf_filtered (file
,
625 _("Script filename extension recognition is \"%s\".\n"),
629 /* Try to open SCRIPT_FILE.
630 If successful, the full path name is stored in *FULL_PATHP,
631 and the stream is returned.
632 If not successful, return NULL; errno is set for the last file
635 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
636 search for it in the source search path. */
638 gdb::optional
<open_script
>
639 find_and_open_script (const char *script_file
, int search_path
)
642 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
643 gdb::optional
<open_script
> opened
;
645 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
648 search_flags
|= OPF_SEARCH_IN_PATH
;
650 /* Search for and open 'file' on the search path used for source
651 files. Put the full location in *FULL_PATHP. */
652 gdb::unique_xmalloc_ptr
<char> full_path
;
653 fd
= openp (source_path
.c_str (), search_flags
,
654 file
.get (), O_RDONLY
, &full_path
);
659 FILE *result
= fdopen (fd
, FOPEN_RT
);
662 int save_errno
= errno
;
668 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
673 /* Load script FILE, which has already been opened as STREAM.
674 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
675 This is provided as FILE may have been found via the source search path.
676 An important thing to note here is that FILE may be a symlink to a file
677 with a different or non-existing suffix, and thus one cannot infer the
678 extension language from FILE_TO_OPEN. */
681 source_script_from_stream (FILE *stream
, const char *file
,
682 const char *file_to_open
)
684 if (script_ext_mode
!= script_ext_off
)
686 const struct extension_language_defn
*extlang
687 = get_ext_lang_of_file (file
);
691 if (ext_lang_present_p (extlang
))
693 script_sourcer_func
*sourcer
694 = ext_lang_script_sourcer (extlang
);
696 gdb_assert (sourcer
!= NULL
);
697 sourcer (extlang
, stream
, file_to_open
);
700 else if (script_ext_mode
== script_ext_soft
)
702 /* Assume the file is a gdb script.
703 This is handled below. */
706 throw_ext_lang_unsupported (extlang
);
710 script_from_file (stream
, file
);
713 /* Worker to perform the "source" command.
715 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
716 search for it in the source search path. */
719 source_script_with_search (const char *file
, int from_tty
, int search_path
)
722 if (file
== NULL
|| *file
== 0)
723 error (_("source command requires file name of file to source."));
725 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
728 /* The script wasn't found, or was otherwise inaccessible.
729 If the source command was invoked interactively, throw an
730 error. Otherwise (e.g. if it was invoked by a script),
731 just emit a warning, rather than cause an error. */
733 perror_with_name (file
);
736 perror_warning_with_name (file
);
741 /* The python support reopens the file, so we need to pass full_path here
742 in case the file was found on the search path. It's useful to do this
743 anyway so that error messages show the actual file used. But only do
744 this if we (may have) used search_path, as printing the full path in
745 errors for the non-search case can be more noise than signal. */
746 const char *file_to_open
;
747 gdb::unique_xmalloc_ptr
<char> tilde_expanded_file
;
749 file_to_open
= opened
->full_path
.get ();
752 tilde_expanded_file
= gdb_tilde_expand_up (file
);
753 file_to_open
= tilde_expanded_file
.get ();
755 source_script_from_stream (opened
->stream
.get (), file
, file_to_open
);
758 /* Wrapper around source_script_with_search to export it to main.c
759 for use in loading .gdbinit scripts. */
762 source_script (const char *file
, int from_tty
)
764 source_script_with_search (file
, from_tty
, 0);
768 source_command (const char *args
, int from_tty
)
770 const char *file
= args
;
773 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
775 /* -v causes the source command to run in verbose mode.
776 -s causes the file to be searched in the source search path,
777 even if the file name contains a '/'.
778 We still have to be able to handle filenames with spaces in a
779 backward compatible way, so buildargv is not appropriate. */
783 while (args
[0] != '\0')
785 /* Make sure leading white space does not break the
787 args
= skip_spaces (args
);
792 if (args
[1] == 'v' && isspace (args
[2]))
796 /* Skip passed -v. */
799 else if (args
[1] == 's' && isspace (args
[2]))
803 /* Skip passed -s. */
810 file
= skip_spaces (args
);
813 source_script_with_search (file
, from_tty
, search_path
);
818 echo_command (const char *text
, int from_tty
)
820 const char *p
= text
;
824 while ((c
= *p
++) != '\0')
828 /* \ at end of argument is used after spaces
829 so they won't be lost. */
833 c
= parse_escape (get_current_arch (), &p
);
835 printf_filtered ("%c", c
);
838 printf_filtered ("%c", c
);
841 reset_terminal_style (gdb_stdout
);
843 /* Force this output to appear now. */
845 gdb_flush (gdb_stdout
);
848 /* Sets the last launched shell command convenience variables based on
852 exit_status_set_internal_vars (int exit_status
)
854 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
855 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
857 clear_internalvar (var_code
);
858 clear_internalvar (var_signal
);
859 if (WIFEXITED (exit_status
))
860 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
862 else if (WIFSIGNALED (exit_status
) && WTERMSIG (exit_status
) == -1)
864 /* The -1 condition can happen on MinGW, if we don't recognize
865 the fatal exception code encoded in the exit status; see
866 gdbsupport/gdb_wait.c. We don't want to lose information in
867 the exit status in that case. Record it as a normal exit
868 with the full exit status, including the higher 0xC0000000
870 set_internalvar_integer (var_code
, exit_status
);
873 else if (WIFSIGNALED (exit_status
))
874 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
876 warning (_("unexpected shell command exit status %d"), exit_status
);
880 shell_escape (const char *arg
, int from_tty
)
882 #if defined(CANT_FORK) || \
883 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
884 /* If ARG is NULL, they want an inferior shell, but `system' just
885 reports if the shell is available when passed a NULL arg. */
886 int rc
= system (arg
? arg
: "");
889 arg
= "inferior shell";
892 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
893 safe_strerror (errno
));
895 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
897 /* Make sure to return to the directory GDB thinks it is, in case
898 the shell command we just ran changed it. */
899 chdir (current_directory
);
901 exit_status_set_internal_vars (rc
);
902 #else /* Can fork. */
905 if ((pid
= vfork ()) == 0)
907 const char *p
, *user_shell
= get_shell ();
911 /* Get the name of the shell for arg0. */
912 p
= lbasename (user_shell
);
915 execl (user_shell
, p
, (char *) 0);
917 execl (user_shell
, p
, "-c", arg
, (char *) 0);
919 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
920 safe_strerror (errno
));
925 waitpid (pid
, &status
, 0);
927 error (_("Fork failed"));
928 exit_status_set_internal_vars (status
);
929 #endif /* Can fork. */
932 /* Implementation of the "shell" command. */
935 shell_command (const char *arg
, int from_tty
)
937 shell_escape (arg
, from_tty
);
941 edit_command (const char *arg
, int from_tty
)
943 struct symtab_and_line sal
;
949 /* Pull in the current default source line if necessary. */
952 set_default_source_symtab_and_line ();
953 sal
= get_current_source_symtab_and_line ();
956 /* Bare "edit" edits file with present line. */
961 error (_("No default source file yet."));
962 sal
.line
+= get_lines_to_list () / 2;
968 /* Now should only be one argument -- decode it in SAL. */
970 event_location_up location
= string_to_event_location (&arg1
,
972 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
973 DECODE_LINE_LIST_MODE
,
982 if (sals
.size () > 1)
984 ambiguous_line_spec (sals
,
985 _("Specified line is ambiguous:\n"));
992 error (_("Junk at end of line specification."));
994 /* If line was specified by address, first print exactly which
995 line, and which file. In this case, sal.symtab == 0 means
996 address is outside of all known source files, not that user
997 failed to give a filename. */
1000 struct gdbarch
*gdbarch
;
1002 if (sal
.symtab
== 0)
1003 error (_("No source file for address %s."),
1004 paddress (get_current_arch (), sal
.pc
));
1006 gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
1007 sym
= find_pc_function (sal
.pc
);
1009 printf_filtered ("%s is in %s (%s:%d).\n",
1010 paddress (gdbarch
, sal
.pc
),
1012 symtab_to_filename_for_display (sal
.symtab
),
1015 printf_filtered ("%s is at %s:%d.\n",
1016 paddress (gdbarch
, sal
.pc
),
1017 symtab_to_filename_for_display (sal
.symtab
),
1021 /* If what was given does not imply a symtab, it must be an
1022 undebuggable symbol which means no source code. */
1024 if (sal
.symtab
== 0)
1025 error (_("No line number known for %s."), arg
);
1028 if ((editor
= getenv ("EDITOR")) == NULL
)
1031 fn
= symtab_to_fullname (sal
.symtab
);
1033 /* Quote the file name, in case it has whitespace or other special
1035 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
1036 shell_escape (p
, from_tty
);
1040 /* The options for the "pipe" command. */
1042 struct pipe_cmd_opts
1045 std::string delimiter
;
1048 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
1050 gdb::option::string_option_def
<pipe_cmd_opts
> {
1052 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
1054 N_("Indicates to use the specified delimiter string to separate\n\
1055 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
1056 case COMMAND contains a | character."),
1061 /* Create an option_def_group for the "pipe" command's options, with
1064 static inline gdb::option::option_def_group
1065 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
1067 return {{pipe_cmd_option_defs
}, opts
};
1070 /* Implementation of the "pipe" command. */
1073 pipe_command (const char *arg
, int from_tty
)
1077 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1078 gdb::option::process_options
1079 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1081 const char *delim
= "|";
1082 if (!opts
.delimiter
.empty ())
1083 delim
= opts
.delimiter
.c_str ();
1085 const char *command
= arg
;
1086 if (command
== nullptr)
1087 error (_("Missing COMMAND"));
1089 arg
= strstr (arg
, delim
);
1092 error (_("Missing delimiter before SHELL_COMMAND"));
1094 std::string
gdb_cmd (command
, arg
- command
);
1096 arg
+= strlen (delim
); /* Skip the delimiter. */
1098 if (gdb_cmd
.empty ())
1099 gdb_cmd
= repeat_previous ();
1101 const char *shell_command
= skip_spaces (arg
);
1102 if (*shell_command
== '\0')
1103 error (_("Missing SHELL_COMMAND"));
1105 FILE *to_shell_command
= popen (shell_command
, "w");
1107 if (to_shell_command
== nullptr)
1108 error (_("Error launching \"%s\""), shell_command
);
1112 stdio_file
pipe_file (to_shell_command
);
1114 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1118 pclose (to_shell_command
);
1122 int exit_status
= pclose (to_shell_command
);
1124 if (exit_status
< 0)
1125 error (_("shell command \"%s\" failed: %s"), shell_command
,
1126 safe_strerror (errno
));
1127 exit_status_set_internal_vars (exit_status
);
1130 /* Completer for the pipe command. */
1133 pipe_command_completer (struct cmd_list_element
*ignore
,
1134 completion_tracker
&tracker
,
1135 const char *text
, const char *word_ignored
)
1139 const char *org_text
= text
;
1140 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1141 if (gdb::option::complete_options
1142 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1145 const char *delimiter
= "|";
1146 if (!opts
.delimiter
.empty ())
1147 delimiter
= opts
.delimiter
.c_str ();
1149 /* Check if we're past option values already. */
1150 if (text
> org_text
&& !isspace (text
[-1]))
1153 const char *delim
= strstr (text
, delimiter
);
1155 /* If we're still not past the delimiter, complete the gdb
1157 if (delim
== nullptr || delim
== text
)
1159 complete_nested_command_line (tracker
, text
);
1163 /* We're past the delimiter. What follows is a shell command, which
1164 we don't know how to complete. */
1168 list_command (const char *arg
, int from_tty
)
1175 int linenum_beg
= 0;
1178 /* Pull in the current default source line if necessary. */
1179 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1181 set_default_source_symtab_and_line ();
1182 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1184 /* If this is the first "list" since we've set the current
1185 source line, center the listing around that line. */
1186 if (get_first_line_listed () == 0)
1190 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1192 /* A small special case --- if listing backwards, and we
1193 should list only one line, list the preceding line,
1194 instead of the exact line we've just shown after e.g.,
1195 stopping for a breakpoint. */
1196 if (arg
!= NULL
&& arg
[0] == '-'
1197 && get_lines_to_list () == 1 && first
> 1)
1200 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1203 /* "l" or "l +" lists next ten lines. */
1204 else if (arg
== NULL
|| arg
[0] == '+')
1205 print_source_lines (cursal
.symtab
,
1206 source_lines_range (cursal
.line
), 0);
1208 /* "l -" lists previous ten lines, the ones before the ten just
1210 else if (arg
[0] == '-')
1212 if (get_first_line_listed () == 1)
1213 error (_("Already at the start of %s."),
1214 symtab_to_filename_for_display (cursal
.symtab
));
1215 source_lines_range
range (get_first_line_listed (),
1216 source_lines_range::BACKWARD
);
1217 print_source_lines (cursal
.symtab
, range
, 0);
1223 /* Now if there is only one argument, decode it in SAL
1225 If there are two arguments, decode them in SAL and SAL_END
1226 and clear NO_END; however, if one of the arguments is blank,
1227 set DUMMY_BEG or DUMMY_END to record that fact. */
1229 if (!have_full_symbols () && !have_partial_symbols ())
1230 error (_("No symbol table is loaded. Use the \"file\" command."));
1232 std::vector
<symtab_and_line
> sals
;
1233 symtab_and_line sal
, sal_end
;
1240 event_location_up location
= string_to_event_location (&arg1
,
1242 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1254 /* Record whether the BEG arg is all digits. */
1256 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1257 linenum_beg
= (p
== arg1
);
1259 /* Save the range of the first argument, in case we need to let the
1260 user know it was ambiguous. */
1261 const char *beg
= arg
;
1262 size_t beg_len
= arg1
- beg
;
1264 while (*arg1
== ' ' || *arg1
== '\t')
1269 if (sals
.size () > 1)
1271 ambiguous_line_spec (sals
,
1272 _("Specified first line '%.*s' is ambiguous:\n"),
1273 (int) beg_len
, beg
);
1277 while (*arg1
== ' ' || *arg1
== '\t')
1283 /* Save the last argument, in case we need to let the user
1284 know it was ambiguous. */
1285 const char *end_arg
= arg1
;
1287 event_location_up location
1288 = string_to_event_location (&arg1
, current_language
);
1290 std::vector
<symtab_and_line
> sals_end
1292 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1294 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1295 NULL
, sal
.symtab
, sal
.line
));
1297 filter_sals (sals_end
);
1298 if (sals_end
.empty ())
1300 if (sals_end
.size () > 1)
1302 ambiguous_line_spec (sals_end
,
1303 _("Specified last line '%s' is ambiguous:\n"),
1307 sal_end
= sals_end
[0];
1312 error (_("Junk at end of line specification."));
1314 if (!no_end
&& !dummy_beg
&& !dummy_end
1315 && sal
.symtab
!= sal_end
.symtab
)
1316 error (_("Specified first and last lines are in different files."));
1317 if (dummy_beg
&& dummy_end
)
1318 error (_("Two empty args do not say what lines to list."));
1320 /* If line was specified by address,
1321 first print exactly which line, and which file.
1323 In this case, sal.symtab == 0 means address is outside of all
1324 known source files, not that user failed to give a filename. */
1327 struct gdbarch
*gdbarch
;
1329 if (sal
.symtab
== 0)
1330 error (_("No source file for address %s."),
1331 paddress (get_current_arch (), sal
.pc
));
1333 gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
1334 sym
= find_pc_function (sal
.pc
);
1336 printf_filtered ("%s is in %s (%s:%d).\n",
1337 paddress (gdbarch
, sal
.pc
),
1339 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1341 printf_filtered ("%s is at %s:%d.\n",
1342 paddress (gdbarch
, sal
.pc
),
1343 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1346 /* If line was not specified by just a line number, and it does not
1347 imply a symtab, it must be an undebuggable symbol which means no
1350 if (!linenum_beg
&& sal
.symtab
== 0)
1351 error (_("No line number known for %s."), arg
);
1353 /* If this command is repeated with RET,
1354 turn it into the no-arg variant. */
1357 set_repeat_arguments ("");
1359 if (dummy_beg
&& sal_end
.symtab
== 0)
1360 error (_("No default source file yet. Do \"help list\"."));
1363 source_lines_range
range (sal_end
.line
+ 1,
1364 source_lines_range::BACKWARD
);
1365 print_source_lines (sal_end
.symtab
, range
, 0);
1367 else if (sal
.symtab
== 0)
1368 error (_("No default source file yet. Do \"help list\"."));
1371 for (int i
= 0; i
< sals
.size (); i
++)
1374 int first_line
= sal
.line
- get_lines_to_list () / 2;
1377 if (sals
.size () > 1)
1378 print_sal_location (sal
);
1379 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1383 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1385 print_source_lines (sal
.symtab
,
1386 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1390 /* Subroutine of disassemble_command to simplify it.
1391 Perform the disassembly.
1392 NAME is the name of the function if known, or NULL.
1393 [LOW,HIGH) are the range of addresses to disassemble.
1394 BLOCK is the block to disassemble; it needs to be provided
1395 when non-contiguous blocks are disassembled; otherwise
1397 MIXED is non-zero to print source with the assembler. */
1400 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1401 CORE_ADDR low
, CORE_ADDR high
,
1402 const struct block
*block
,
1403 gdb_disassembly_flags flags
)
1406 if (tui_is_window_visible (DISASSEM_WIN
))
1407 tui_show_assembly (gdbarch
, low
);
1411 printf_filtered (_("Dump of assembler code "));
1413 printf_filtered (_("for function %ps:\n"),
1414 styled_string (function_name_style
.style (), name
));
1415 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1418 printf_filtered (_("from %ps to %ps:\n"),
1419 styled_string (address_style
.style (),
1420 paddress (gdbarch
, low
)),
1421 styled_string (address_style
.style (),
1422 paddress (gdbarch
, high
)));
1424 /* Dump the specified range. */
1425 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1429 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1431 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1432 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1433 printf_filtered (_("Address range %ps to %ps:\n"),
1434 styled_string (address_style
.style (),
1435 paddress (gdbarch
, range_low
)),
1436 styled_string (address_style
.style (),
1437 paddress (gdbarch
, range_high
)));
1438 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1439 range_low
, range_high
);
1442 printf_filtered (_("End of assembler dump.\n"));
1446 /* Subroutine of disassemble_command to simplify it.
1447 Print a disassembly of the current function according to FLAGS. */
1450 disassemble_current_function (gdb_disassembly_flags flags
)
1452 struct frame_info
*frame
;
1453 struct gdbarch
*gdbarch
;
1454 CORE_ADDR low
, high
, pc
;
1456 const struct block
*block
;
1458 frame
= get_selected_frame (_("No frame selected."));
1459 gdbarch
= get_frame_arch (frame
);
1460 pc
= get_frame_address_in_block (frame
);
1461 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1462 error (_("No function contains program counter for selected frame."));
1464 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1467 /* FIXME: cagney/2004-02-07: This should be an observer. */
1468 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1470 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1472 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1475 /* Dump a specified section of assembly code.
1479 - dump the assembly code for the function of the current pc
1480 disassemble [/mrs] addr
1481 - dump the assembly code for the function at ADDR
1482 disassemble [/mrs] low,high
1483 disassemble [/mrs] low,+length
1484 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1486 A /m modifier will include source code with the assembly in a
1487 "source centric" view. This view lists only the file of the first insn,
1488 even if other source files are involved (e.g., inlined functions), and
1489 the output is in source order, even with optimized code. This view is
1490 considered deprecated as it hasn't been useful in practice.
1492 A /r modifier will include raw instructions in hex with the assembly.
1494 A /s modifier will include source code with the assembly, like /m, with
1495 two important differences:
1496 1) The output is still in pc address order.
1497 2) File names and contents for all relevant source files are displayed. */
1500 disassemble_command (const char *arg
, int from_tty
)
1502 struct gdbarch
*gdbarch
= get_current_arch ();
1503 CORE_ADDR low
, high
;
1504 const general_symbol_info
*symbol
= nullptr;
1507 gdb_disassembly_flags flags
;
1509 const struct block
*block
= nullptr;
1520 error (_("Missing modifier."));
1522 while (*p
&& ! isspace (*p
))
1527 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1530 flags
|= DISASSEMBLY_RAW_INSN
;
1533 flags
|= DISASSEMBLY_SOURCE
;
1536 error (_("Invalid disassembly modifier."));
1540 p
= skip_spaces (p
);
1543 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1544 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1545 error (_("Cannot specify both /m and /s."));
1549 flags
|= DISASSEMBLY_OMIT_FNAME
;
1550 disassemble_current_function (flags
);
1554 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1560 if (!find_pc_partial_function_sym (pc
, &symbol
, &low
, &high
, &block
))
1561 error (_("No function contains specified address."));
1564 name
= symbol
->print_name ();
1566 name
= symbol
->linkage_name ();
1569 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1572 /* FIXME: cagney/2004-02-07: This should be an observer. */
1573 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1575 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1576 flags
|= DISASSEMBLY_OMIT_FNAME
;
1580 /* Two arguments. */
1583 p
= skip_spaces (p
);
1589 high
= parse_and_eval_address (p
);
1594 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1598 make_command (const char *arg
, int from_tty
)
1601 shell_escape ("make", from_tty
);
1604 std::string cmd
= std::string ("make ") + arg
;
1606 shell_escape (cmd
.c_str (), from_tty
);
1611 show_user (const char *args
, int from_tty
)
1613 struct cmd_list_element
*c
;
1617 const char *comname
= args
;
1619 c
= lookup_cmd (&comname
, cmdlist
, "", NULL
, 0, 1);
1620 if (!cli_user_command_p (c
))
1621 error (_("Not a user command."));
1622 show_user_1 (c
, "", args
, gdb_stdout
);
1626 for (c
= cmdlist
; c
; c
= c
->next
)
1628 if (cli_user_command_p (c
) || c
->is_prefix ())
1629 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1634 /* Search through names of commands and documentations for a certain
1635 regular expression. */
1638 apropos_command (const char *arg
, int from_tty
)
1640 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1642 if (arg
== NULL
|| *arg
== '\0')
1643 error (_("REGEXP string is empty"));
1645 compiled_regex
pattern (arg
, REG_ICASE
,
1646 _("Error in regular expression"));
1648 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1651 /* The options for the "alias" command. */
1656 bool abbrev_flag
= false;
1659 static const gdb::option::option_def alias_option_defs
[] = {
1661 gdb::option::flag_option_def
<alias_opts
> {
1663 [] (alias_opts
*opts
) { return &opts
->abbrev_flag
; },
1664 N_("Specify that ALIAS is an abbreviation of COMMAND.\n\
1665 Abbreviations are not used in command completion."),
1670 /* Create an option_def_group for the "alias" options, with
1671 A_OPTS as context. */
1673 static gdb::option::option_def_group
1674 make_alias_options_def_group (alias_opts
*a_opts
)
1676 return {{alias_option_defs
}, a_opts
};
1679 /* Completer for the "alias_command". */
1682 alias_command_completer (struct cmd_list_element
*ignore
,
1683 completion_tracker
&tracker
,
1684 const char *text
, const char *word
)
1686 const auto grp
= make_alias_options_def_group (nullptr);
1688 tracker
.set_use_custom_word_point (true);
1690 if (gdb::option::complete_options
1691 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1694 const char *delim
= strchr (text
, '=');
1696 /* If we're past the "=" delimiter, complete the
1697 "alias ALIAS = COMMAND [DEFAULT-ARGS...]" as if the user is
1698 typing COMMAND DEFAULT-ARGS... */
1701 && isspace (delim
[-1])
1702 && (isspace (delim
[1]) || delim
[1] == '\0'))
1704 std::string new_text
= std::string (delim
+ 1);
1706 tracker
.advance_custom_word_point_by (delim
+ 1 - text
);
1707 complete_nested_command_line (tracker
, new_text
.c_str ());
1711 /* We're not yet past the "=" delimiter. Complete a command, as
1712 the user might type an alias following a prefix command. */
1713 complete_nested_command_line (tracker
, text
);
1716 /* Subroutine of alias_command to simplify it.
1717 Return the first N elements of ARGV flattened back to a string
1718 with a space separating each element.
1719 ARGV may not be NULL.
1720 This does not take care of quoting elements in case they contain spaces
1724 argv_to_string (char **argv
, int n
)
1729 gdb_assert (argv
!= NULL
);
1730 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1732 for (i
= 0; i
< n
; ++i
)
1742 /* Subroutine of alias_command to simplify it.
1743 Verifies that COMMAND can have an alias:
1745 COMMAND must not have default args.
1746 This last condition is to avoid the following:
1747 alias aaa = backtrace -full
1748 alias bbb = aaa -past-main
1749 as (at least currently), alias default args are not cumulative
1750 and the user would expect bbb to execute 'backtrace -full -past-main'
1751 while it will execute 'backtrace -past-main'. */
1753 static cmd_list_element
*
1754 validate_aliased_command (const char *command
)
1756 std::string default_args
;
1758 = lookup_cmd_1 (& command
, cmdlist
, NULL
, &default_args
, 1);
1760 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1761 error (_("Invalid command to alias to: %s"), command
);
1763 if (!default_args
.empty ())
1764 error (_("Cannot define an alias of an alias that has default args"));
1769 /* Called when "alias" was incorrectly used. */
1772 alias_usage_error (void)
1774 error (_("Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]"));
1777 /* Make an alias of an existing command. */
1780 alias_command (const char *args
, int from_tty
)
1784 auto grp
= make_alias_options_def_group (&a_opts
);
1785 gdb::option::process_options
1786 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1788 int i
, alias_argc
, command_argc
;
1790 const char *alias
, *command
;
1792 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1793 alias_usage_error ();
1795 equals
= strchr (args
, '=');
1796 std::string
args2 (args
, equals
- args
);
1798 gdb_argv
built_alias_argv (args2
.c_str ());
1800 const char *default_args
= equals
+ 1;
1801 struct cmd_list_element
*c_command_prefix
;
1803 lookup_cmd_for_default_args (&default_args
, &c_command_prefix
);
1804 std::string
command_argv_str (equals
+ 1,
1805 default_args
== nullptr
1806 ? strlen (equals
+ 1)
1807 : default_args
- equals
- 1);
1808 gdb_argv
command_argv (command_argv_str
.c_str ());
1810 char **alias_argv
= built_alias_argv
.get ();
1812 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1813 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1814 alias_usage_error ();
1816 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1818 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1821 error (_("Invalid command name: %s"), alias_argv
[i
]);
1823 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1827 alias_argc
= countargv (alias_argv
);
1828 command_argc
= command_argv
.count ();
1830 /* COMMAND must exist, and cannot have default args.
1831 Reconstruct the command to remove any extraneous spaces,
1832 for better error messages. */
1833 std::string
command_string (argv_to_string (command_argv
.get (),
1835 command
= command_string
.c_str ();
1836 cmd_list_element
*target_cmd
= validate_aliased_command (command
);
1838 /* ALIAS must not exist. */
1839 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1840 alias
= alias_string
.c_str ();
1842 cmd_list_element
*alias_cmd
, *prefix_cmd
, *cmd
;
1844 if (lookup_cmd_composition (alias
, &alias_cmd
, &prefix_cmd
, &cmd
))
1846 const char *alias_name
= alias_argv
[alias_argc
-1];
1848 /* If we found an existing ALIAS_CMD, check that the prefix differ or
1851 if (alias_cmd
!= nullptr
1852 && alias_cmd
->prefix
== prefix_cmd
1853 && strcmp (alias_name
, alias_cmd
->name
) == 0)
1854 error (_("Alias already exists: %s"), alias
);
1856 /* Check ALIAS differs from the found CMD. */
1858 if (cmd
->prefix
== prefix_cmd
1859 && strcmp (alias_name
, cmd
->name
) == 0)
1860 error (_("Alias %s is the name of an existing command"), alias
);
1865 struct cmd_list_element
*alias_cmd
;
1867 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1868 Example: alias spe = set print elements
1870 Otherwise ALIAS and COMMAND must have the same number of words,
1871 and every word except the last must identify the same prefix command;
1872 and the last word of ALIAS is made an alias of the last word of COMMAND.
1873 Example: alias set print elms = set pr elem
1874 Note that unambiguous abbreviations are allowed. */
1876 if (alias_argc
== 1)
1878 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1879 alias_cmd
= add_com_alias (xstrdup (alias_argv
[0]), target_cmd
,
1880 class_alias
, a_opts
.abbrev_flag
);
1884 const char *alias_prefix
, *command_prefix
;
1885 struct cmd_list_element
*c_alias
, *c_command
;
1887 if (alias_argc
!= command_argc
)
1888 error (_("Mismatched command length between ALIAS and COMMAND."));
1890 /* Create copies of ALIAS and COMMAND without the last word,
1891 and use that to verify the leading elements give the same
1893 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1895 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1897 alias_prefix
= alias_prefix_string
.c_str ();
1898 command_prefix
= command_prefix_string
.c_str ();
1900 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, NULL
, 1);
1901 /* We've already tried to look up COMMAND. */
1902 gdb_assert (c_command
!= NULL
1903 && c_command
!= (struct cmd_list_element
*) -1);
1904 gdb_assert (c_command
->is_prefix ());
1905 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, NULL
, 1);
1906 if (c_alias
!= c_command
)
1907 error (_("ALIAS and COMMAND prefixes do not match."));
1909 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1910 alias_cmd
= add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1911 target_cmd
, class_alias
, a_opts
.abbrev_flag
,
1912 c_command
->subcommands
);
1915 gdb_assert (alias_cmd
!= nullptr);
1916 gdb_assert (alias_cmd
->default_args
.empty ());
1917 if (default_args
!= nullptr)
1919 default_args
= skip_spaces (default_args
);
1921 alias_cmd
->default_args
= default_args
;
1925 /* Print the file / line number / symbol name of the location
1926 specified by SAL. */
1929 print_sal_location (const symtab_and_line
&sal
)
1931 scoped_restore_current_program_space restore_pspace
;
1932 set_current_program_space (sal
.pspace
);
1934 const char *sym_name
= NULL
;
1935 if (sal
.symbol
!= NULL
)
1936 sym_name
= sal
.symbol
->print_name ();
1937 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1938 symtab_to_filename_for_display (sal
.symtab
),
1939 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1942 /* Print a list of files and line numbers which a user may choose from
1943 in order to list a function which was specified ambiguously (as
1944 with `list classname::overloadedfuncname', for example). The SALS
1945 array provides the filenames and line numbers. FORMAT is a
1946 printf-style format string used to tell the user what was
1950 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1951 const char *format
, ...)
1954 va_start (ap
, format
);
1955 vprintf_filtered (format
, ap
);
1958 for (const auto &sal
: sals
)
1959 print_sal_location (sal
);
1962 /* Comparison function for filter_sals. Returns a qsort-style
1966 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1968 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1969 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1977 else if (dirb
== NULL
)
1984 r
= filename_cmp (dira
, dirb
);
1989 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1993 if (sala
.line
< salb
.line
)
1995 return sala
.line
== salb
.line
? 0 : 1;
1998 /* Remove any SALs that do not match the current program space, or
1999 which appear to be "file:line" duplicates. */
2002 filter_sals (std::vector
<symtab_and_line
> &sals
)
2004 /* Remove SALs that do not match. */
2005 auto from
= std::remove_if (sals
.begin (), sals
.end (),
2006 [&] (const symtab_and_line
&sal
)
2007 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
2010 std::sort (sals
.begin (), from
,
2011 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
2012 { return cmp_symtabs (sala
, salb
) < 0; });
2014 from
= std::unique (sals
.begin (), from
,
2015 [&] (const symtab_and_line
&sala
,
2016 const symtab_and_line
&salb
)
2017 { return cmp_symtabs (sala
, salb
) == 0; });
2019 sals
.erase (from
, sals
.end ());
2023 init_cmd_lists (void)
2025 max_user_call_depth
= 1024;
2029 show_info_verbose (struct ui_file
*file
, int from_tty
,
2030 struct cmd_list_element
*c
,
2034 fprintf_filtered (file
,
2035 _("Verbose printing of informational messages is %s.\n"),
2038 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
2042 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
2043 struct cmd_list_element
*c
, const char *value
)
2045 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
2050 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
2051 struct cmd_list_element
*c
, const char *value
)
2053 fprintf_filtered (file
,
2054 _("The max call depth for user-defined commands is %s.\n"),
2058 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
2059 argument of ARGV, which must contain one single value.
2060 Throws an error if no value provided, or value not correct.
2061 FNNAME is used in the error message. */
2063 static cmd_list_element
*
2064 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
2065 int argc
, struct value
**argv
)
2068 error (_("You must provide an argument to %s"), fnname
);
2070 error (_("You can only provide one argument to %s"), fnname
);
2072 struct type
*type0
= check_typedef (value_type (argv
[0]));
2074 if (type0
->code () != TYPE_CODE_ARRAY
2075 && type0
->code () != TYPE_CODE_STRING
)
2076 error (_("First argument of %s must be a string."), fnname
);
2078 const char *a0
= (const char *) value_contents (argv
[0]).data ();
2079 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", NULL
, -1, 0);
2081 if (cmd
== nullptr || cmd
->type
!= show_cmd
)
2082 error (_("First argument of %s must be a "
2083 "valid setting of the 'show' command."), fnname
);
2088 /* Builds a value from the show CMD. */
2090 static struct value
*
2091 value_from_setting (const setting
&var
, struct gdbarch
*gdbarch
)
2093 switch (var
.type ())
2096 if (var
.get
<int> () == INT_MAX
)
2097 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2100 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2103 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2106 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2107 var
.get
<bool> () ? 1 : 0);
2108 case var_zuinteger_unlimited
:
2109 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2111 case var_auto_boolean
:
2115 switch (var
.get
<enum auto_boolean
> ())
2117 case AUTO_BOOLEAN_TRUE
:
2120 case AUTO_BOOLEAN_FALSE
:
2123 case AUTO_BOOLEAN_AUTO
:
2127 gdb_assert_not_reached ("invalid var_auto_boolean");
2129 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2133 if (var
.get
<unsigned int> () == UINT_MAX
)
2134 return value_from_ulongest
2135 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
2137 return value_from_ulongest
2138 (builtin_type (gdbarch
)->builtin_unsigned_int
,
2139 var
.get
<unsigned int> ());
2141 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
2142 var
.get
<unsigned int> ());
2144 case var_string_noescape
:
2145 case var_optional_filename
:
2151 if (var
.type () == var_enum
)
2153 value
= var
.get
<const char *> ();
2154 len
= strlen (value
);
2158 const std::string
&st
= var
.get
<std::string
> ();
2159 value
= st
.c_str ();
2164 return value_cstring (value
, len
,
2165 builtin_type (gdbarch
)->builtin_char
);
2167 return value_cstring ("", 1,
2168 builtin_type (gdbarch
)->builtin_char
);
2171 gdb_assert_not_reached ("bad var_type");
2175 /* Implementation of the convenience function $_gdb_setting. */
2177 static struct value
*
2178 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
2179 const struct language_defn
*language
,
2180 void *cookie
, int argc
, struct value
**argv
)
2182 cmd_list_element
*show_cmd
2183 = setting_cmd ("$_gdb_setting", showlist
, argc
, argv
);
2185 gdb_assert (show_cmd
->var
.has_value ());
2187 return value_from_setting (*show_cmd
->var
, gdbarch
);
2190 /* Implementation of the convenience function $_gdb_maint_setting. */
2192 static struct value
*
2193 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2194 const struct language_defn
*language
,
2195 void *cookie
, int argc
, struct value
**argv
)
2197 cmd_list_element
*show_cmd
2198 = setting_cmd ("$_gdb_maint_setting", maintenance_show_cmdlist
, argc
, argv
);
2200 gdb_assert (show_cmd
->var
.has_value ());
2202 return value_from_setting (*show_cmd
->var
, gdbarch
);
2205 /* Builds a string value from the show CMD. */
2207 static struct value
*
2208 str_value_from_setting (const setting
&var
, struct gdbarch
*gdbarch
)
2210 switch (var
.type ())
2215 case var_zuinteger_unlimited
:
2216 case var_auto_boolean
:
2220 std::string cmd_val
= get_setshow_command_value_string (var
);
2222 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2223 builtin_type (gdbarch
)->builtin_char
);
2227 case var_string_noescape
:
2228 case var_optional_filename
:
2231 /* For these cases, we do not use get_setshow_command_value_string,
2232 as this function handle some characters specially, e.g. by
2233 escaping quotevar. So, we directly use the var string value,
2234 similarly to the value_from_setting code for these casevar. */
2238 if (var
.type () == var_enum
)
2240 value
= var
.get
<const char *> ();
2241 len
= strlen (value
);
2245 const std::string
&st
= var
.get
<std::string
> ();
2246 value
= st
.c_str ();
2251 return value_cstring (value
, len
,
2252 builtin_type (gdbarch
)->builtin_char
);
2254 return value_cstring ("", 1,
2255 builtin_type (gdbarch
)->builtin_char
);
2258 gdb_assert_not_reached ("bad var_type");
2262 /* Implementation of the convenience function $_gdb_setting_str. */
2264 static struct value
*
2265 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2266 const struct language_defn
*language
,
2267 void *cookie
, int argc
, struct value
**argv
)
2269 cmd_list_element
*show_cmd
2270 = setting_cmd ("$_gdb_setting_str", showlist
, argc
, argv
);
2272 gdb_assert (show_cmd
->var
.has_value ());
2274 return str_value_from_setting (*show_cmd
->var
, gdbarch
);
2278 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2280 static struct value
*
2281 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2282 const struct language_defn
*language
,
2283 void *cookie
, int argc
, struct value
**argv
)
2285 cmd_list_element
*show_cmd
2286 = setting_cmd ("$_gdb_maint_setting_str", maintenance_show_cmdlist
, argc
,
2289 gdb_assert (show_cmd
->var
.has_value ());
2291 return str_value_from_setting (*show_cmd
->var
, gdbarch
);
2294 void _initialize_cli_cmds ();
2296 _initialize_cli_cmds ()
2298 struct cmd_list_element
*c
;
2300 /* Define the classes of commands.
2301 They will appear in the help list in alphabetical order. */
2303 add_cmd ("internals", class_maintenance
, _("\
2304 Maintenance commands.\n\
2305 Some gdb commands are provided just for use by gdb maintainers.\n\
2306 These commands are subject to frequent change, and may not be as\n\
2307 well documented as user commands."),
2309 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2310 add_cmd ("aliases", class_alias
,
2311 _("User-defined aliases of other commands."), &cmdlist
);
2312 add_cmd ("user-defined", class_user
, _("\
2313 User-defined commands.\n\
2314 The commands in this class are those defined by the user.\n\
2315 Use the \"define\" command to define a command."), &cmdlist
);
2316 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2318 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2319 add_cmd ("files", class_files
, _("Specifying and examining files."),
2321 add_cmd ("breakpoints", class_breakpoint
,
2322 _("Making program stop at certain points."), &cmdlist
);
2323 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2324 add_cmd ("stack", class_stack
, _("\
2325 Examining the stack.\n\
2326 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2327 counting from zero for the innermost (currently executing) frame.\n\n\
2328 At any time gdb identifies one frame as the \"selected\" frame.\n\
2329 Variable lookups are done with respect to the selected frame.\n\
2330 When the program being debugged stops, gdb selects the innermost frame.\n\
2331 The commands below can be used to select other frames by number or address."),
2334 add_cmd ("text-user-interface", class_tui
,
2335 _("TUI is the GDB text based interface.\n\
2336 In TUI mode, GDB can display several text windows showing\n\
2337 the source file, the processor registers, the program disassembly, ..."), &cmdlist
);
2339 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2341 /* Define general commands. */
2343 add_com ("pwd", class_files
, pwd_command
, _("\
2344 Print working directory.\n\
2345 This is used for your program as well."));
2347 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2348 Set working directory to DIR for debugger.\n\
2349 The debugger's current working directory specifies where scripts and other\n\
2350 files that can be loaded by GDB are located.\n\
2351 In order to change the inferior's current working directory, the recommended\n\
2352 way is to use the \"set cwd\" command."), &cmdlist
);
2353 set_cmd_completer (c
, filename_completer
);
2355 add_com ("echo", class_support
, echo_command
, _("\
2356 Print a constant string. Give string as argument.\n\
2357 C escape sequences may be used in the argument.\n\
2358 No newline is added at the end of the argument;\n\
2359 use \"\\n\" if you want a newline to be printed.\n\
2360 Since leading and trailing whitespace are ignored in command arguments,\n\
2361 if you want to print some you must use \"\\\" before leading whitespace\n\
2362 to be printed or after trailing whitespace."));
2364 add_setshow_enum_cmd ("script-extension", class_support
,
2365 script_ext_enums
, &script_ext_mode
, _("\
2366 Set mode for script filename extension recognition."), _("\
2367 Show mode for script filename extension recognition."), _("\
2368 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2369 soft == evaluate script according to filename extension, fallback to GDB script"
2371 strict == evaluate script according to filename extension, error if not supported"
2374 show_script_ext_mode
,
2375 &setlist
, &showlist
);
2377 cmd_list_element
*quit_cmd
2378 = add_com ("quit", class_support
, quit_command
, _("\
2380 Usage: quit [EXPR]\n\
2381 The optional expression EXPR, if present, is evaluated and the result\n\
2382 used as GDB's exit code. The default is zero."));
2383 cmd_list_element
*help_cmd
2384 = add_com ("help", class_support
, help_command
,
2385 _("Print list of commands."));
2386 set_cmd_completer (help_cmd
, command_completer
);
2387 add_com_alias ("q", quit_cmd
, class_support
, 1);
2388 add_com_alias ("h", help_cmd
, class_support
, 1);
2390 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2391 Set verbosity."), _("\
2392 Show verbosity."), NULL
,
2395 &setlist
, &showlist
);
2397 add_setshow_prefix_cmd
2398 ("history", class_support
,
2399 _("Generic command for setting command history parameters."),
2400 _("Generic command for showing command history parameters."),
2401 &sethistlist
, &showhistlist
, &setlist
, &showlist
);
2403 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2404 Set history expansion on command input."), _("\
2405 Show history expansion on command input."), _("\
2406 Without an argument, history expansion is enabled."),
2408 show_history_expansion_p
,
2409 &sethistlist
, &showhistlist
);
2411 cmd_list_element
*info_cmd
2412 = add_prefix_cmd ("info", class_info
, info_command
, _("\
2413 Generic command for showing things about the program being debugged."),
2414 &infolist
, 0, &cmdlist
);
2415 add_com_alias ("i", info_cmd
, class_info
, 1);
2416 add_com_alias ("inf", info_cmd
, class_info
, 1);
2418 add_com ("complete", class_obscure
, complete_command
,
2419 _("List the completions for the rest of the line as a command."));
2421 c
= add_show_prefix_cmd ("show", class_info
, _("\
2422 Generic command for showing things about the debugger."),
2423 &showlist
, 0, &cmdlist
);
2424 /* Another way to get at the same thing. */
2425 add_alias_cmd ("set", c
, class_info
, 0, &infolist
);
2427 cmd_list_element
*with_cmd
2428 = add_com ("with", class_vars
, with_command
, _("\
2429 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2430 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2431 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2432 With no COMMAND, repeats the last executed command.\n\
2434 SETTING is any setting you can change with the \"set\" subcommands.\n\
2436 with language pascal -- print obj\n\
2437 with print elements unlimited -- print obj\n\
2439 You can change multiple settings using nested with, and use\n\
2440 abbreviations for commands and/or values. E.g.:\n\
2441 w la p -- w p el u -- p obj"));
2442 set_cmd_completer_handle_brkchars (with_cmd
, with_command_completer
);
2443 add_com_alias ("w", with_cmd
, class_vars
, 1);
2445 add_internal_function ("_gdb_setting_str", _("\
2446 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2447 Usage: $_gdb_setting_str (setting)\n\
2449 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2450 boolean values are \"off\", \"on\".\n\
2451 Some integer settings accept an unlimited value, returned\n\
2452 as \"unlimited\"."),
2453 gdb_setting_str_internal_fn
, NULL
);
2455 add_internal_function ("_gdb_setting", _("\
2456 $_gdb_setting - returns the value of a GDB setting.\n\
2457 Usage: $_gdb_setting (setting)\n\
2458 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2459 boolean values are \"off\", \"on\".\n\
2460 Some integer settings accept an unlimited value, returned\n\
2461 as 0 or -1 depending on the setting."),
2462 gdb_setting_internal_fn
, NULL
);
2464 add_internal_function ("_gdb_maint_setting_str", _("\
2465 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2466 Usage: $_gdb_maint_setting_str (setting)\n\
2468 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2469 boolean values are \"off\", \"on\".\n\
2470 Some integer settings accept an unlimited value, returned\n\
2471 as \"unlimited\"."),
2472 gdb_maint_setting_str_internal_fn
, NULL
);
2474 add_internal_function ("_gdb_maint_setting", _("\
2475 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2476 Usage: $_gdb_maint_setting (setting)\n\
2477 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2478 boolean values are \"off\", \"on\".\n\
2479 Some integer settings accept an unlimited value, returned\n\
2480 as 0 or -1 depending on the setting."),
2481 gdb_maint_setting_internal_fn
, NULL
);
2483 add_cmd ("commands", no_set_class
, show_commands
, _("\
2484 Show the history of commands you typed.\n\
2485 You can supply a command number to start with, or a `+' to start after\n\
2486 the previous command number shown."),
2489 add_cmd ("version", no_set_class
, show_version
,
2490 _("Show what version of GDB this is."), &showlist
);
2492 add_cmd ("configuration", no_set_class
, show_configuration
,
2493 _("Show how GDB was configured at build time."), &showlist
);
2495 add_setshow_prefix_cmd ("debug", no_class
,
2496 _("Generic command for setting gdb debugging flags."),
2497 _("Generic command for showing gdb debugging flags."),
2498 &setdebuglist
, &showdebuglist
,
2499 &setlist
, &showlist
);
2501 cmd_list_element
*shell_cmd
2502 = add_com ("shell", class_support
, shell_command
, _("\
2503 Execute the rest of the line as a shell command.\n\
2504 With no arguments, run an inferior shell."));
2505 set_cmd_completer (shell_cmd
, filename_completer
);
2507 add_com_alias ("!", shell_cmd
, class_support
, 0);
2509 c
= add_com ("edit", class_files
, edit_command
, _("\
2510 Edit specified file or function.\n\
2511 With no argument, edits file containing most recent line listed.\n\
2512 Editing targets can be specified in these ways:\n\
2513 FILE:LINENUM, to edit at that line in that file,\n\
2514 FUNCTION, to edit at the beginning of that function,\n\
2515 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2516 *ADDRESS, to edit at the line containing that address.\n\
2517 Uses EDITOR environment variable contents as editor (or ex as default)."));
2519 c
->completer
= location_completer
;
2521 cmd_list_element
*pipe_cmd
2522 = add_com ("pipe", class_support
, pipe_command
, _("\
2523 Send the output of a gdb command to a shell command.\n\
2524 Usage: | [COMMAND] | SHELL_COMMAND\n\
2525 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2526 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2527 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2529 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2531 The -d option indicates to use the string DELIM to separate COMMAND\n\
2532 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2533 case COMMAND contains a | character.\n\
2535 With no COMMAND, repeat the last executed command\n\
2536 and send its output to SHELL_COMMAND."));
2537 set_cmd_completer_handle_brkchars (pipe_cmd
, pipe_command_completer
);
2538 add_com_alias ("|", pipe_cmd
, class_support
, 0);
2540 cmd_list_element
*list_cmd
2541 = add_com ("list", class_files
, list_command
, _("\
2542 List specified function or line.\n\
2543 With no argument, lists ten more lines after or around previous listing.\n\
2544 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2545 One argument specifies a line, and ten lines are listed around that line.\n\
2546 Two arguments with comma between specify starting and ending lines to list.\n\
2547 Lines can be specified in these ways:\n\
2548 LINENUM, to list around that line in current file,\n\
2549 FILE:LINENUM, to list around that line in that file,\n\
2550 FUNCTION, to list around beginning of that function,\n\
2551 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2552 *ADDRESS, to list around the line containing that address.\n\
2553 With two args, if one is empty, it stands for ten lines away from\n\
2556 By default, when a single location is given, display ten lines.\n\
2557 This can be changed using \"set listsize\", and the current value\n\
2558 can be shown using \"show listsize\"."));
2560 add_com_alias ("l", list_cmd
, class_files
, 1);
2563 add_com_alias ("file", list_cmd
, class_files
, 1);
2565 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2566 Disassemble a specified section of memory.\n\
2567 Usage: disassemble[/m|/r|/s] START [, END]\n\
2568 Default is the function surrounding the pc of the selected frame.\n\
2570 With a /s modifier, source lines are included (if available).\n\
2571 In this mode, the output is displayed in PC address order, and\n\
2572 file names and contents for all relevant source files are displayed.\n\
2574 With a /m modifier, source lines are included (if available).\n\
2575 This view is \"source centric\": the output is in source line order,\n\
2576 regardless of any optimization that is present. Only the main source file\n\
2577 is displayed, not those of, e.g., any inlined functions.\n\
2578 This modifier hasn't proved useful in practice and is deprecated\n\
2581 With a /r modifier, raw instructions in hex are included.\n\
2583 With a single argument, the function surrounding that address is dumped.\n\
2584 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2585 in the form of \"start,end\", or \"start,+length\".\n\
2587 Note that the address is interpreted as an expression, not as a location\n\
2588 like in the \"break\" command.\n\
2589 So, for example, if you want to disassemble function bar in file foo.c\n\
2590 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2591 set_cmd_completer (c
, location_completer
);
2593 c
= add_com ("make", class_support
, make_command
, _("\
2594 Run the ``make'' program using the rest of the line as arguments."));
2595 set_cmd_completer (c
, filename_completer
);
2596 add_cmd ("user", no_class
, show_user
, _("\
2597 Show definitions of non-python/scheme user defined commands.\n\
2598 Argument is the name of the user defined command.\n\
2599 With no argument, show definitions of all user defined commands."), &showlist
);
2600 add_com ("apropos", class_support
, apropos_command
, _("\
2601 Search for commands matching a REGEXP.\n\
2602 Usage: apropos [-v] REGEXP\n\
2603 Flag -v indicates to produce a verbose output, showing full documentation\n\
2604 of the matching commands."));
2606 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2607 &max_user_call_depth
, _("\
2608 Set the max call depth for non-python/scheme user-defined commands."), _("\
2609 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2611 show_max_user_call_depth
,
2612 &setlist
, &showlist
);
2614 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2615 Set tracing of GDB CLI commands."), _("\
2616 Show state of GDB CLI command tracing."), _("\
2617 When 'on', each command is displayed as it is executed."),
2620 &setlist
, &showlist
);
2622 const auto alias_opts
= make_alias_options_def_group (nullptr);
2624 static std::string alias_help
2625 = gdb::option::build_help (_("\
2626 Define a new command that is an alias of an existing command.\n\
2627 Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]\n\
2628 ALIAS is the name of the alias command to create.\n\
2629 COMMAND is the command being aliased to.\n\
2634 GDB will automatically prepend the provided DEFAULT-ARGS to the list\n\
2635 of arguments explicitly provided when using ALIAS.\n\
2636 Use \"help aliases\" to list all user defined aliases and their default args.\n\
2639 Make \"spe\" an alias of \"set print elements\":\n\
2640 alias spe = set print elements\n\
2641 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2642 alias -a set print elms = set print elements\n\
2643 Make \"btf\" an alias of \"backtrace -full -past-entry -past-main\" :\n\
2644 alias btf = backtrace -full -past-entry -past-main\n\
2645 Make \"wLapPeu\" an alias of 2 nested \"with\":\n\
2646 alias wLapPeu = with language pascal -- with print elements unlimited --"),
2649 c
= add_com ("alias", class_support
, alias_command
,
2650 alias_help
.c_str ());
2652 set_cmd_completer_handle_brkchars (c
, alias_command_completer
);
2654 const char *source_help_text
= xstrprintf (_("\
2655 Read commands from a file named FILE.\n\
2657 Usage: source [-s] [-v] FILE\n\
2658 -s: search for the script in the source search path,\n\
2659 even if FILE contains directories.\n\
2660 -v: each command in FILE is echoed as it is executed.\n\
2662 Note that the file \"%s\" is read automatically in this way\n\
2663 when GDB is started."), GDBINIT
);
2664 c
= add_cmd ("source", class_support
, source_command
,
2665 source_help_text
, &cmdlist
);
2666 set_cmd_completer (c
, filename_completer
);