3 Copyright (C) 2000-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
22 #include "readline/readline.h"
23 #include "readline/tilde.h"
24 #include "completer.h"
25 #include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
26 #include "gdbsupport/gdb_wait.h" /* For shell escape implementation. */
28 #include "gdb_regex.h" /* Used by apropos_command. */
29 #include "gdb_vfork.h"
31 #include "expression.h"
35 #include "filenames.h" /* For DOSish file names. */
39 #include "tracepoint.h"
40 #include "gdbsupport/filestuff.h"
48 #include "cli/cli-decode.h"
49 #include "cli/cli-script.h"
50 #include "cli/cli-setshow.h"
51 #include "cli/cli-cmds.h"
52 #include "cli/cli-utils.h"
54 #include "extension.h"
55 #include "gdbsupport/pathstuff.h"
58 #include "tui/tui.h" /* For tui_active et.al. */
65 /* Prototypes for local utility functions */
67 static void print_sal_location (const symtab_and_line
&sal
);
69 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
70 const char *format
, ...)
71 ATTRIBUTE_PRINTF (2, 3);
73 static void filter_sals (std::vector
<symtab_and_line
> &);
76 /* Limit the call depth of user-defined commands */
77 unsigned int max_user_call_depth
;
79 /* Define all cmd_list_elements. */
81 /* Chain containing all defined commands. */
83 struct cmd_list_element
*cmdlist
;
85 /* Chain containing all defined info subcommands. */
87 struct cmd_list_element
*infolist
;
89 /* Chain containing all defined enable subcommands. */
91 struct cmd_list_element
*enablelist
;
93 /* Chain containing all defined disable subcommands. */
95 struct cmd_list_element
*disablelist
;
97 /* Chain containing all defined stop subcommands. */
99 struct cmd_list_element
*stoplist
;
101 /* Chain containing all defined delete subcommands. */
103 struct cmd_list_element
*deletelist
;
105 /* Chain containing all defined detach subcommands. */
107 struct cmd_list_element
*detachlist
;
109 /* Chain containing all defined kill subcommands. */
111 struct cmd_list_element
*killlist
;
113 /* Chain containing all defined set subcommands */
115 struct cmd_list_element
*setlist
;
117 /* Chain containing all defined unset subcommands */
119 struct cmd_list_element
*unsetlist
;
121 /* Chain containing all defined show subcommands. */
123 struct cmd_list_element
*showlist
;
125 /* Chain containing all defined \"set history\". */
127 struct cmd_list_element
*sethistlist
;
129 /* Chain containing all defined \"show history\". */
131 struct cmd_list_element
*showhistlist
;
133 /* Chain containing all defined \"unset history\". */
135 struct cmd_list_element
*unsethistlist
;
137 /* Chain containing all defined maintenance subcommands. */
139 struct cmd_list_element
*maintenancelist
;
141 /* Chain containing all defined "maintenance info" subcommands. */
143 struct cmd_list_element
*maintenanceinfolist
;
145 /* Chain containing all defined "maintenance print" subcommands. */
147 struct cmd_list_element
*maintenanceprintlist
;
149 /* Chain containing all defined "maintenance check" subcommands. */
151 struct cmd_list_element
*maintenancechecklist
;
153 struct cmd_list_element
*setprintlist
;
155 struct cmd_list_element
*showprintlist
;
157 struct cmd_list_element
*setdebuglist
;
159 struct cmd_list_element
*showdebuglist
;
161 struct cmd_list_element
*setchecklist
;
163 struct cmd_list_element
*showchecklist
;
165 /* Command tracing state. */
167 int source_verbose
= 0;
168 int trace_commands
= 0;
170 /* 'script-extension' option support. */
172 static const char script_ext_off
[] = "off";
173 static const char script_ext_soft
[] = "soft";
174 static const char script_ext_strict
[] = "strict";
176 static const char *const script_ext_enums
[] = {
183 static const char *script_ext_mode
= script_ext_soft
;
185 /* Utility used everywhere when at least one argument is needed and
189 error_no_arg (const char *why
)
191 error (_("Argument required (%s)."), why
);
194 /* The "info" command is defined as a prefix, with allow_unknown = 0.
195 Therefore, its own definition is called only for "info" with no
199 info_command (const char *arg
, int from_tty
)
201 printf_unfiltered (_("\"info\" must be followed by "
202 "the name of an info command.\n"));
203 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
206 /* The "show" command with no arguments shows all the settings. */
209 show_command (const char *arg
, int from_tty
)
211 cmd_show_list (showlist
, from_tty
, "");
214 /* See cli/cli-cmds.h. */
217 with_command_1 (const char *set_cmd_prefix
,
218 cmd_list_element
*setlist
, const char *args
, int from_tty
)
220 const char *delim
= strstr (args
, "--");
221 const char *nested_cmd
= nullptr;
224 error (_("Missing setting before '--' delimiter"));
226 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
227 nested_cmd
= repeat_previous ();
229 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
230 /*allow_unknown=*/ 0,
231 /*ignore_help_classes=*/ 1);
232 gdb_assert (set_cmd
!= nullptr);
234 if (set_cmd
->var
== nullptr)
235 error (_("Cannot use this setting with the \"with\" command"));
237 std::string temp_value
238 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
240 if (nested_cmd
== nullptr)
241 nested_cmd
= skip_spaces (delim
+ 2);
243 std::string org_value
= get_setshow_command_value_string (set_cmd
);
245 /* Tweak the setting to the new temporary value. */
246 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
250 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
252 /* Execute the nested command. */
253 execute_command (nested_cmd
, from_tty
);
255 catch (const gdb_exception
&ex
)
257 /* Restore the setting and rethrow. If restoring the setting
258 throws, swallow the new exception and warn. There's nothing
259 else we can reasonably do. */
262 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
264 catch (const gdb_exception
&ex2
)
266 warning (_("Couldn't restore setting: %s"), ex2
.what ());
272 /* Restore the setting. */
273 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
276 /* See cli/cli-cmds.h. */
279 with_command_completer_1 (const char *set_cmd_prefix
,
280 completion_tracker
&tracker
,
283 tracker
.set_use_custom_word_point (true);
285 const char *delim
= strstr (text
, "--");
287 /* If we're still not past the "--" delimiter, complete the "with"
288 command as if it was a "set" command. */
291 || !isspace (delim
[-1])
292 || !(isspace (delim
[2]) || delim
[2] == '\0'))
294 std::string new_text
= std::string (set_cmd_prefix
) + text
;
295 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
296 complete_nested_command_line (tracker
, new_text
.c_str ());
300 /* We're past the "--" delimiter. Complete on the sub command. */
301 const char *nested_cmd
= skip_spaces (delim
+ 2);
302 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
303 complete_nested_command_line (tracker
, nested_cmd
);
306 /* The "with" command. */
309 with_command (const char *args
, int from_tty
)
311 with_command_1 ("set ", setlist
, args
, from_tty
);
314 /* "with" command completer. */
317 with_command_completer (struct cmd_list_element
*ignore
,
318 completion_tracker
&tracker
,
319 const char *text
, const char * /*word*/)
321 with_command_completer_1 ("set ", tracker
, text
);
325 /* Provide documentation on command or list given by COMMAND. FROM_TTY
329 help_command (const char *command
, int from_tty
)
331 help_cmd (command
, gdb_stdout
);
335 /* Note: The "complete" command is used by Emacs to implement completion.
336 [Is that why this function writes output with *_unfiltered?] */
339 complete_command (const char *arg
, int from_tty
)
343 if (max_completions
== 0)
345 /* Only print this for non-mi frontends. An MI frontend may not
346 be able to handle this. */
347 if (!current_uiout
->is_mi_like_p ())
349 printf_unfiltered (_("max-completions is zero,"
350 " completion is disabled.\n"));
358 int quote_char
= '\0';
361 completion_result result
= complete (arg
, &word
, "e_char
);
363 if (result
.number_matches
!= 0)
365 std::string
arg_prefix (arg
, word
- arg
);
367 if (result
.number_matches
== 1)
368 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
371 result
.sort_match_list ();
373 for (size_t i
= 0; i
< result
.number_matches
; i
++)
375 printf_unfiltered ("%s%s",
377 result
.match_list
[i
+ 1]);
379 printf_unfiltered ("%c", quote_char
);
380 printf_unfiltered ("\n");
384 if (result
.number_matches
== max_completions
)
386 /* ARG_PREFIX and WORD are included in the output so that emacs
387 will include the message in the output. */
388 printf_unfiltered (_("%s%s %s\n"),
389 arg_prefix
.c_str (), word
,
390 get_max_completions_reached_message ());
396 is_complete_command (struct cmd_list_element
*c
)
398 return cmd_cfunc_eq (c
, complete_command
);
402 show_version (const char *args
, int from_tty
)
404 print_gdb_version (gdb_stdout
, true);
405 printf_filtered ("\n");
409 show_configuration (const char *args
, int from_tty
)
411 print_gdb_configuration (gdb_stdout
);
414 /* Handle the quit command. */
417 quit_command (const char *args
, int from_tty
)
421 /* An optional expression may be used to cause gdb to terminate with
422 the value of that expression. */
425 struct value
*val
= parse_and_eval (args
);
427 exit_code
= (int) value_as_long (val
);
430 if (!quit_confirm ())
431 error (_("Not confirmed."));
433 query_if_trace_running (from_tty
);
435 quit_force (args
? &exit_code
: NULL
, from_tty
);
439 pwd_command (const char *args
, int from_tty
)
442 error (_("The \"pwd\" command does not take an argument: %s"), args
);
444 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
447 error (_("Error finding name of working directory: %s"),
448 safe_strerror (errno
));
450 if (strcmp (cwd
.get (), current_directory
) != 0)
451 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
452 current_directory
, cwd
.get ());
454 printf_unfiltered (_("Working directory %s.\n"), current_directory
);
458 cd_command (const char *dir
, int from_tty
)
461 /* Found something other than leading repetitions of "/..". */
465 /* If the new directory is absolute, repeat is a no-op; if relative,
466 repeat might be useful but is more likely to be a mistake. */
469 gdb::unique_xmalloc_ptr
<char> dir_holder
470 (tilde_expand (dir
!= NULL
? dir
: "~"));
471 dir
= dir_holder
.get ();
474 perror_with_name (dir
);
476 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
477 /* There's too much mess with DOSish names like "d:", "d:.",
478 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
479 simply get the canonicalized name of the current directory. */
480 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
485 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
487 /* Remove the trailing slash unless this is a root directory
488 (including a drive letter on non-Unix systems). */
489 if (!(len
== 1) /* "/" */
490 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
491 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
497 dir_holder
.reset (savestring (dir
, len
));
498 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
500 xfree (current_directory
);
501 current_directory
= dir_holder
.release ();
505 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
506 current_directory
= concat (current_directory
, dir_holder
.get (),
509 current_directory
= concat (current_directory
, SLASH_STRING
,
510 dir_holder
.get (), (char *) NULL
);
513 /* Now simplify any occurrences of `.' and `..' in the pathname. */
516 for (p
= current_directory
; *p
;)
518 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
519 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
520 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
521 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
522 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
526 /* Search backwards for the directory just before the "/.."
527 and obliterate it and the "/..". */
530 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
533 if (q
== current_directory
)
534 /* current_directory is
535 a relative pathname ("can't happen"--leave it alone). */
539 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
544 /* We are dealing with leading repetitions of "/..", for
545 example "/../..", which is the Mach super-root. */
555 forget_cached_source_info ();
558 pwd_command ((char *) 0, 1);
561 /* Show the current value of the 'script-extension' option. */
564 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
565 struct cmd_list_element
*c
, const char *value
)
567 fprintf_filtered (file
,
568 _("Script filename extension recognition is \"%s\".\n"),
572 /* Try to open SCRIPT_FILE.
573 If successful, the full path name is stored in *FULL_PATHP,
574 and the stream is returned.
575 If not successful, return NULL; errno is set for the last file
578 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
579 search for it in the source search path. */
581 gdb::optional
<open_script
>
582 find_and_open_script (const char *script_file
, int search_path
)
585 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
586 gdb::optional
<open_script
> opened
;
588 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
591 search_flags
|= OPF_SEARCH_IN_PATH
;
593 /* Search for and open 'file' on the search path used for source
594 files. Put the full location in *FULL_PATHP. */
595 gdb::unique_xmalloc_ptr
<char> full_path
;
596 fd
= openp (source_path
, search_flags
,
597 file
.get (), O_RDONLY
, &full_path
);
602 FILE *result
= fdopen (fd
, FOPEN_RT
);
605 int save_errno
= errno
;
611 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
616 /* Load script FILE, which has already been opened as STREAM.
617 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
618 This is provided as FILE may have been found via the source search path.
619 An important thing to note here is that FILE may be a symlink to a file
620 with a different or non-existing suffix, and thus one cannot infer the
621 extension language from FILE_TO_OPEN. */
624 source_script_from_stream (FILE *stream
, const char *file
,
625 const char *file_to_open
)
627 if (script_ext_mode
!= script_ext_off
)
629 const struct extension_language_defn
*extlang
630 = get_ext_lang_of_file (file
);
634 if (ext_lang_present_p (extlang
))
636 script_sourcer_func
*sourcer
637 = ext_lang_script_sourcer (extlang
);
639 gdb_assert (sourcer
!= NULL
);
640 sourcer (extlang
, stream
, file_to_open
);
643 else if (script_ext_mode
== script_ext_soft
)
645 /* Assume the file is a gdb script.
646 This is handled below. */
649 throw_ext_lang_unsupported (extlang
);
653 script_from_file (stream
, file
);
656 /* Worker to perform the "source" command.
658 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
659 search for it in the source search path. */
662 source_script_with_search (const char *file
, int from_tty
, int search_path
)
665 if (file
== NULL
|| *file
== 0)
666 error (_("source command requires file name of file to source."));
668 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
671 /* The script wasn't found, or was otherwise inaccessible.
672 If the source command was invoked interactively, throw an
673 error. Otherwise (e.g. if it was invoked by a script),
674 just emit a warning, rather than cause an error. */
676 perror_with_name (file
);
679 perror_warning_with_name (file
);
684 /* The python support reopens the file, so we need to pass full_path here
685 in case the file was found on the search path. It's useful to do this
686 anyway so that error messages show the actual file used. But only do
687 this if we (may have) used search_path, as printing the full path in
688 errors for the non-search case can be more noise than signal. */
689 source_script_from_stream (opened
->stream
.get (), file
,
690 search_path
? opened
->full_path
.get () : file
);
693 /* Wrapper around source_script_with_search to export it to main.c
694 for use in loading .gdbinit scripts. */
697 source_script (const char *file
, int from_tty
)
699 source_script_with_search (file
, from_tty
, 0);
703 source_command (const char *args
, int from_tty
)
705 const char *file
= args
;
708 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
710 /* -v causes the source command to run in verbose mode.
711 -s causes the file to be searched in the source search path,
712 even if the file name contains a '/'.
713 We still have to be able to handle filenames with spaces in a
714 backward compatible way, so buildargv is not appropriate. */
718 while (args
[0] != '\0')
720 /* Make sure leading white space does not break the
722 args
= skip_spaces (args
);
727 if (args
[1] == 'v' && isspace (args
[2]))
731 /* Skip passed -v. */
734 else if (args
[1] == 's' && isspace (args
[2]))
738 /* Skip passed -s. */
745 file
= skip_spaces (args
);
748 source_script_with_search (file
, from_tty
, search_path
);
753 echo_command (const char *text
, int from_tty
)
755 const char *p
= text
;
759 while ((c
= *p
++) != '\0')
763 /* \ at end of argument is used after spaces
764 so they won't be lost. */
768 c
= parse_escape (get_current_arch (), &p
);
770 printf_filtered ("%c", c
);
773 printf_filtered ("%c", c
);
776 reset_terminal_style (gdb_stdout
);
778 /* Force this output to appear now. */
780 gdb_flush (gdb_stdout
);
783 /* Sets the last launched shell command convenience variables based on
787 exit_status_set_internal_vars (int exit_status
)
789 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
790 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
792 clear_internalvar (var_code
);
793 clear_internalvar (var_signal
);
794 if (WIFEXITED (exit_status
))
795 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
796 else if (WIFSIGNALED (exit_status
))
797 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
799 warning (_("unexpected shell command exit status %d"), exit_status
);
803 shell_escape (const char *arg
, int from_tty
)
805 #if defined(CANT_FORK) || \
806 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
807 /* If ARG is NULL, they want an inferior shell, but `system' just
808 reports if the shell is available when passed a NULL arg. */
809 int rc
= system (arg
? arg
: "");
812 arg
= "inferior shell";
815 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
816 safe_strerror (errno
));
818 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
820 /* Make sure to return to the directory GDB thinks it is, in case
821 the shell command we just ran changed it. */
822 chdir (current_directory
);
823 exit_status_set_internal_vars (rc
);
825 #else /* Can fork. */
828 if ((pid
= vfork ()) == 0)
830 const char *p
, *user_shell
= get_shell ();
834 /* Get the name of the shell for arg0. */
835 p
= lbasename (user_shell
);
838 execl (user_shell
, p
, (char *) 0);
840 execl (user_shell
, p
, "-c", arg
, (char *) 0);
842 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
843 safe_strerror (errno
));
848 waitpid (pid
, &status
, 0);
850 error (_("Fork failed"));
851 exit_status_set_internal_vars (status
);
852 #endif /* Can fork. */
855 /* Implementation of the "shell" command. */
858 shell_command (const char *arg
, int from_tty
)
860 shell_escape (arg
, from_tty
);
864 edit_command (const char *arg
, int from_tty
)
866 struct symtab_and_line sal
;
872 /* Pull in the current default source line if necessary. */
875 set_default_source_symtab_and_line ();
876 sal
= get_current_source_symtab_and_line ();
879 /* Bare "edit" edits file with present line. */
884 error (_("No default source file yet."));
885 sal
.line
+= get_lines_to_list () / 2;
891 /* Now should only be one argument -- decode it in SAL. */
893 event_location_up location
= string_to_event_location (&arg1
,
895 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
896 DECODE_LINE_LIST_MODE
,
905 if (sals
.size () > 1)
907 ambiguous_line_spec (sals
,
908 _("Specified line is ambiguous:\n"));
915 error (_("Junk at end of line specification."));
917 /* If line was specified by address, first print exactly which
918 line, and which file. In this case, sal.symtab == 0 means
919 address is outside of all known source files, not that user
920 failed to give a filename. */
923 struct gdbarch
*gdbarch
;
926 error (_("No source file for address %s."),
927 paddress (get_current_arch (), sal
.pc
));
929 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
930 sym
= find_pc_function (sal
.pc
);
932 printf_filtered ("%s is in %s (%s:%d).\n",
933 paddress (gdbarch
, sal
.pc
),
934 SYMBOL_PRINT_NAME (sym
),
935 symtab_to_filename_for_display (sal
.symtab
),
938 printf_filtered ("%s is at %s:%d.\n",
939 paddress (gdbarch
, sal
.pc
),
940 symtab_to_filename_for_display (sal
.symtab
),
944 /* If what was given does not imply a symtab, it must be an
945 undebuggable symbol which means no source code. */
948 error (_("No line number known for %s."), arg
);
951 if ((editor
= getenv ("EDITOR")) == NULL
)
954 fn
= symtab_to_fullname (sal
.symtab
);
956 /* Quote the file name, in case it has whitespace or other special
958 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
959 shell_escape (p
, from_tty
);
963 /* The options for the "pipe" command. */
968 char *delimiter
= nullptr;
976 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
978 gdb::option::string_option_def
<pipe_cmd_opts
> {
980 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
982 N_("Indicates to use the specified delimiter string to separate\n\
983 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
984 case COMMAND contains a | character."),
989 /* Create an option_def_group for the "pipe" command's options, with
992 static inline gdb::option::option_def_group
993 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
995 return {{pipe_cmd_option_defs
}, opts
};
998 /* Implementation of the "pipe" command. */
1001 pipe_command (const char *arg
, int from_tty
)
1005 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1006 gdb::option::process_options
1007 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1009 const char *delim
= "|";
1010 if (opts
.delimiter
!= nullptr)
1011 delim
= opts
.delimiter
;
1013 const char *command
= arg
;
1014 if (command
== nullptr)
1015 error (_("Missing COMMAND"));
1017 arg
= strstr (arg
, delim
);
1020 error (_("Missing delimiter before SHELL_COMMAND"));
1022 std::string
gdb_cmd (command
, arg
- command
);
1024 arg
+= strlen (delim
); /* Skip the delimiter. */
1026 if (gdb_cmd
.empty ())
1027 gdb_cmd
= repeat_previous ();
1029 const char *shell_command
= skip_spaces (arg
);
1030 if (*shell_command
== '\0')
1031 error (_("Missing SHELL_COMMAND"));
1033 FILE *to_shell_command
= popen (shell_command
, "w");
1035 if (to_shell_command
== nullptr)
1036 error (_("Error launching \"%s\""), shell_command
);
1040 stdio_file
pipe_file (to_shell_command
);
1042 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1046 pclose (to_shell_command
);
1050 int exit_status
= pclose (to_shell_command
);
1052 if (exit_status
< 0)
1053 error (_("shell command \"%s\" failed: %s"), shell_command
,
1054 safe_strerror (errno
));
1055 exit_status_set_internal_vars (exit_status
);
1058 /* Completer for the pipe command. */
1061 pipe_command_completer (struct cmd_list_element
*ignore
,
1062 completion_tracker
&tracker
,
1063 const char *text
, const char *word_ignored
)
1067 const char *org_text
= text
;
1068 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1069 if (gdb::option::complete_options
1070 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1073 const char *delimiter
= "|";
1074 if (opts
.delimiter
!= nullptr)
1075 delimiter
= opts
.delimiter
;
1077 /* Check if we're past option values already. */
1078 if (text
> org_text
&& !isspace (text
[-1]))
1081 const char *delim
= strstr (text
, delimiter
);
1083 /* If we're still not past the delimiter, complete the gdb
1085 if (delim
== nullptr || delim
== text
)
1087 complete_nested_command_line (tracker
, text
);
1091 /* We're past the delimiter. What follows is a shell command, which
1092 we don't know how to complete. */
1096 list_command (const char *arg
, int from_tty
)
1103 int linenum_beg
= 0;
1106 /* Pull in the current default source line if necessary. */
1107 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1109 set_default_source_symtab_and_line ();
1110 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1112 /* If this is the first "list" since we've set the current
1113 source line, center the listing around that line. */
1114 if (get_first_line_listed () == 0)
1118 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1120 /* A small special case --- if listing backwards, and we
1121 should list only one line, list the preceding line,
1122 instead of the exact line we've just shown after e.g.,
1123 stopping for a breakpoint. */
1124 if (arg
!= NULL
&& arg
[0] == '-'
1125 && get_lines_to_list () == 1 && first
> 1)
1128 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1131 /* "l" or "l +" lists next ten lines. */
1132 else if (arg
== NULL
|| arg
[0] == '+')
1133 print_source_lines (cursal
.symtab
,
1134 source_lines_range (cursal
.line
), 0);
1136 /* "l -" lists previous ten lines, the ones before the ten just
1138 else if (arg
[0] == '-')
1140 if (get_first_line_listed () == 1)
1141 error (_("Already at the start of %s."),
1142 symtab_to_filename_for_display (cursal
.symtab
));
1143 source_lines_range
range (get_first_line_listed (),
1144 source_lines_range::BACKWARD
);
1145 print_source_lines (cursal
.symtab
, range
, 0);
1151 /* Now if there is only one argument, decode it in SAL
1153 If there are two arguments, decode them in SAL and SAL_END
1154 and clear NO_END; however, if one of the arguments is blank,
1155 set DUMMY_BEG or DUMMY_END to record that fact. */
1157 if (!have_full_symbols () && !have_partial_symbols ())
1158 error (_("No symbol table is loaded. Use the \"file\" command."));
1160 std::vector
<symtab_and_line
> sals
;
1161 symtab_and_line sal
, sal_end
;
1168 event_location_up location
= string_to_event_location (&arg1
,
1170 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1182 /* Record whether the BEG arg is all digits. */
1184 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1185 linenum_beg
= (p
== arg1
);
1187 /* Save the range of the first argument, in case we need to let the
1188 user know it was ambiguous. */
1189 const char *beg
= arg
;
1190 size_t beg_len
= arg1
- beg
;
1192 while (*arg1
== ' ' || *arg1
== '\t')
1197 if (sals
.size () > 1)
1199 ambiguous_line_spec (sals
,
1200 _("Specified first line '%.*s' is ambiguous:\n"),
1201 (int) beg_len
, beg
);
1205 while (*arg1
== ' ' || *arg1
== '\t')
1211 /* Save the last argument, in case we need to let the user
1212 know it was ambiguous. */
1213 const char *end_arg
= arg1
;
1215 event_location_up location
1216 = string_to_event_location (&arg1
, current_language
);
1218 std::vector
<symtab_and_line
> sals_end
1220 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1222 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1223 NULL
, sal
.symtab
, sal
.line
));
1225 filter_sals (sals_end
);
1226 if (sals_end
.empty ())
1228 if (sals_end
.size () > 1)
1230 ambiguous_line_spec (sals_end
,
1231 _("Specified last line '%s' is ambiguous:\n"),
1235 sal_end
= sals_end
[0];
1240 error (_("Junk at end of line specification."));
1242 if (!no_end
&& !dummy_beg
&& !dummy_end
1243 && sal
.symtab
!= sal_end
.symtab
)
1244 error (_("Specified first and last lines are in different files."));
1245 if (dummy_beg
&& dummy_end
)
1246 error (_("Two empty args do not say what lines to list."));
1248 /* If line was specified by address,
1249 first print exactly which line, and which file.
1251 In this case, sal.symtab == 0 means address is outside of all
1252 known source files, not that user failed to give a filename. */
1255 struct gdbarch
*gdbarch
;
1257 if (sal
.symtab
== 0)
1258 error (_("No source file for address %s."),
1259 paddress (get_current_arch (), sal
.pc
));
1261 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1262 sym
= find_pc_function (sal
.pc
);
1264 printf_filtered ("%s is in %s (%s:%d).\n",
1265 paddress (gdbarch
, sal
.pc
),
1266 SYMBOL_PRINT_NAME (sym
),
1267 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1269 printf_filtered ("%s is at %s:%d.\n",
1270 paddress (gdbarch
, sal
.pc
),
1271 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1274 /* If line was not specified by just a line number, and it does not
1275 imply a symtab, it must be an undebuggable symbol which means no
1278 if (!linenum_beg
&& sal
.symtab
== 0)
1279 error (_("No line number known for %s."), arg
);
1281 /* If this command is repeated with RET,
1282 turn it into the no-arg variant. */
1285 set_repeat_arguments ("");
1287 if (dummy_beg
&& sal_end
.symtab
== 0)
1288 error (_("No default source file yet. Do \"help list\"."));
1291 source_lines_range
range (sal_end
.line
+ 1,
1292 source_lines_range::BACKWARD
);
1293 print_source_lines (sal_end
.symtab
, range
, 0);
1295 else if (sal
.symtab
== 0)
1296 error (_("No default source file yet. Do \"help list\"."));
1299 for (int i
= 0; i
< sals
.size (); i
++)
1302 int first_line
= sal
.line
- get_lines_to_list () / 2;
1305 if (sals
.size () > 1)
1306 print_sal_location (sal
);
1307 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1311 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1313 print_source_lines (sal
.symtab
,
1314 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1318 /* Subroutine of disassemble_command to simplify it.
1319 Perform the disassembly.
1320 NAME is the name of the function if known, or NULL.
1321 [LOW,HIGH) are the range of addresses to disassemble.
1322 BLOCK is the block to disassemble; it needs to be provided
1323 when non-contiguous blocks are disassembled; otherwise
1325 MIXED is non-zero to print source with the assembler. */
1328 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1329 CORE_ADDR low
, CORE_ADDR high
,
1330 const struct block
*block
,
1331 gdb_disassembly_flags flags
)
1334 if (!tui_is_window_visible (DISASSEM_WIN
))
1337 printf_filtered ("Dump of assembler code ");
1339 printf_filtered ("for function %s:\n", name
);
1340 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1343 printf_filtered ("from %s to %s:\n",
1344 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1346 /* Dump the specified range. */
1347 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1351 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1353 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1354 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1355 printf_filtered (_("Address range %s to %s:\n"),
1356 paddress (gdbarch
, range_low
),
1357 paddress (gdbarch
, range_high
));
1358 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1359 range_low
, range_high
);
1362 printf_filtered ("End of assembler dump.\n");
1367 tui_show_assembly (gdbarch
, low
);
1372 /* Subroutine of disassemble_command to simplify it.
1373 Print a disassembly of the current function according to FLAGS. */
1376 disassemble_current_function (gdb_disassembly_flags flags
)
1378 struct frame_info
*frame
;
1379 struct gdbarch
*gdbarch
;
1380 CORE_ADDR low
, high
, pc
;
1382 const struct block
*block
;
1384 frame
= get_selected_frame (_("No frame selected."));
1385 gdbarch
= get_frame_arch (frame
);
1386 pc
= get_frame_address_in_block (frame
);
1387 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1388 error (_("No function contains program counter for selected frame."));
1390 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1393 /* FIXME: cagney/2004-02-07: This should be an observer. */
1394 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1396 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1398 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1401 /* Dump a specified section of assembly code.
1405 - dump the assembly code for the function of the current pc
1406 disassemble [/mrs] addr
1407 - dump the assembly code for the function at ADDR
1408 disassemble [/mrs] low,high
1409 disassemble [/mrs] low,+length
1410 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1412 A /m modifier will include source code with the assembly in a
1413 "source centric" view. This view lists only the file of the first insn,
1414 even if other source files are involved (e.g., inlined functions), and
1415 the output is in source order, even with optimized code. This view is
1416 considered deprecated as it hasn't been useful in practice.
1418 A /r modifier will include raw instructions in hex with the assembly.
1420 A /s modifier will include source code with the assembly, like /m, with
1421 two important differences:
1422 1) The output is still in pc address order.
1423 2) File names and contents for all relevant source files are displayed. */
1426 disassemble_command (const char *arg
, int from_tty
)
1428 struct gdbarch
*gdbarch
= get_current_arch ();
1429 CORE_ADDR low
, high
;
1432 gdb_disassembly_flags flags
;
1434 const struct block
*block
= nullptr;
1445 error (_("Missing modifier."));
1447 while (*p
&& ! isspace (*p
))
1452 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1455 flags
|= DISASSEMBLY_RAW_INSN
;
1458 flags
|= DISASSEMBLY_SOURCE
;
1461 error (_("Invalid disassembly modifier."));
1465 p
= skip_spaces (p
);
1468 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1469 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1470 error (_("Cannot specify both /m and /s."));
1474 flags
|= DISASSEMBLY_OMIT_FNAME
;
1475 disassemble_current_function (flags
);
1479 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1485 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1486 error (_("No function contains specified address."));
1488 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1491 /* FIXME: cagney/2004-02-07: This should be an observer. */
1492 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1494 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1495 flags
|= DISASSEMBLY_OMIT_FNAME
;
1499 /* Two arguments. */
1502 p
= skip_spaces (p
);
1508 high
= parse_and_eval_address (p
);
1513 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1517 make_command (const char *arg
, int from_tty
)
1520 shell_escape ("make", from_tty
);
1523 std::string cmd
= std::string ("make ") + arg
;
1525 shell_escape (cmd
.c_str (), from_tty
);
1530 show_user (const char *args
, int from_tty
)
1532 struct cmd_list_element
*c
;
1533 extern struct cmd_list_element
*cmdlist
;
1537 const char *comname
= args
;
1539 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1540 if (!cli_user_command_p (c
))
1541 error (_("Not a user command."));
1542 show_user_1 (c
, "", args
, gdb_stdout
);
1546 for (c
= cmdlist
; c
; c
= c
->next
)
1548 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1549 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1554 /* Search through names of commands and documentations for a certain
1555 regular expression. */
1558 apropos_command (const char *arg
, int from_tty
)
1560 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1562 if (arg
== NULL
|| *arg
== '\0')
1563 error (_("REGEXP string is empty"));
1565 compiled_regex
pattern (arg
, REG_ICASE
,
1566 _("Error in regular expression"));
1568 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1571 /* Subroutine of alias_command to simplify it.
1572 Return the first N elements of ARGV flattened back to a string
1573 with a space separating each element.
1574 ARGV may not be NULL.
1575 This does not take care of quoting elements in case they contain spaces
1579 argv_to_string (char **argv
, int n
)
1584 gdb_assert (argv
!= NULL
);
1585 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1587 for (i
= 0; i
< n
; ++i
)
1597 /* Subroutine of alias_command to simplify it.
1598 Return true if COMMAND exists, unambiguously. Otherwise false. */
1601 valid_command_p (const char *command
)
1603 struct cmd_list_element
*c
;
1605 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1607 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1610 /* This is the slightly tricky part.
1611 lookup_cmd_1 will return a pointer to the last part of COMMAND
1612 to match, leaving COMMAND pointing at the remainder. */
1613 while (*command
== ' ' || *command
== '\t')
1615 return *command
== '\0';
1618 /* Called when "alias" was incorrectly used. */
1621 alias_usage_error (void)
1623 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1626 /* Make an alias of an existing command. */
1629 alias_command (const char *args
, int from_tty
)
1631 int i
, alias_argc
, command_argc
;
1632 int abbrev_flag
= 0;
1634 const char *alias
, *command
;
1636 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1637 alias_usage_error ();
1639 equals
= strchr (args
, '=');
1640 std::string
args2 (args
, equals
- args
);
1642 gdb_argv
built_alias_argv (args2
.c_str ());
1643 gdb_argv
command_argv (equals
+ 1);
1645 char **alias_argv
= built_alias_argv
.get ();
1646 while (alias_argv
[0] != NULL
)
1648 if (strcmp (alias_argv
[0], "-a") == 0)
1653 else if (strcmp (alias_argv
[0], "--") == 0)
1662 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1663 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1664 alias_usage_error ();
1666 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1668 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1671 error (_("Invalid command name: %s"), alias_argv
[i
]);
1673 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1677 alias_argc
= countargv (alias_argv
);
1678 command_argc
= command_argv
.count ();
1680 /* COMMAND must exist.
1681 Reconstruct the command to remove any extraneous spaces,
1682 for better error messages. */
1683 std::string
command_string (argv_to_string (command_argv
.get (),
1685 command
= command_string
.c_str ();
1686 if (! valid_command_p (command
))
1687 error (_("Invalid command to alias to: %s"), command
);
1689 /* ALIAS must not exist. */
1690 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1691 alias
= alias_string
.c_str ();
1692 if (valid_command_p (alias
))
1693 error (_("Alias already exists: %s"), alias
);
1695 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1696 Example: alias spe = set print elements
1698 Otherwise ALIAS and COMMAND must have the same number of words,
1699 and every word except the last must identify the same prefix command;
1700 and the last word of ALIAS is made an alias of the last word of COMMAND.
1701 Example: alias set print elms = set pr elem
1702 Note that unambiguous abbreviations are allowed. */
1704 if (alias_argc
== 1)
1706 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1707 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1712 const char *alias_prefix
, *command_prefix
;
1713 struct cmd_list_element
*c_alias
, *c_command
;
1715 if (alias_argc
!= command_argc
)
1716 error (_("Mismatched command length between ALIAS and COMMAND."));
1718 /* Create copies of ALIAS and COMMAND without the last word,
1719 and use that to verify the leading elements give the same
1721 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1723 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1725 alias_prefix
= alias_prefix_string
.c_str ();
1726 command_prefix
= command_prefix_string
.c_str ();
1728 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1729 /* We've already tried to look up COMMAND. */
1730 gdb_assert (c_command
!= NULL
1731 && c_command
!= (struct cmd_list_element
*) -1);
1732 gdb_assert (c_command
->prefixlist
!= NULL
);
1733 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1734 if (c_alias
!= c_command
)
1735 error (_("ALIAS and COMMAND prefixes do not match."));
1737 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1738 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1739 command_argv
[command_argc
- 1],
1740 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1744 /* Print the file / line number / symbol name of the location
1745 specified by SAL. */
1748 print_sal_location (const symtab_and_line
&sal
)
1750 scoped_restore_current_program_space restore_pspace
;
1751 set_current_program_space (sal
.pspace
);
1753 const char *sym_name
= NULL
;
1754 if (sal
.symbol
!= NULL
)
1755 sym_name
= SYMBOL_PRINT_NAME (sal
.symbol
);
1756 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1757 symtab_to_filename_for_display (sal
.symtab
),
1758 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1761 /* Print a list of files and line numbers which a user may choose from
1762 in order to list a function which was specified ambiguously (as
1763 with `list classname::overloadedfuncname', for example). The SALS
1764 array provides the filenames and line numbers. FORMAT is a
1765 printf-style format string used to tell the user what was
1769 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1770 const char *format
, ...)
1773 va_start (ap
, format
);
1774 vprintf_filtered (format
, ap
);
1777 for (const auto &sal
: sals
)
1778 print_sal_location (sal
);
1781 /* Comparison function for filter_sals. Returns a qsort-style
1785 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1787 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1788 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1796 else if (dirb
== NULL
)
1803 r
= filename_cmp (dira
, dirb
);
1808 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1812 if (sala
.line
< salb
.line
)
1814 return sala
.line
== salb
.line
? 0 : 1;
1817 /* Remove any SALs that do not match the current program space, or
1818 which appear to be "file:line" duplicates. */
1821 filter_sals (std::vector
<symtab_and_line
> &sals
)
1823 /* Remove SALs that do not match. */
1824 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1825 [&] (const symtab_and_line
&sal
)
1826 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1829 std::sort (sals
.begin (), from
,
1830 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1831 { return cmp_symtabs (sala
, salb
) < 0; });
1833 from
= std::unique (sals
.begin (), from
,
1834 [&] (const symtab_and_line
&sala
,
1835 const symtab_and_line
&salb
)
1836 { return cmp_symtabs (sala
, salb
) == 0; });
1838 sals
.erase (from
, sals
.end ());
1842 set_debug (const char *arg
, int from_tty
)
1844 printf_unfiltered (_("\"set debug\" must be followed by "
1845 "the name of a debug subcommand.\n"));
1846 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1850 show_debug (const char *args
, int from_tty
)
1852 cmd_show_list (showdebuglist
, from_tty
, "");
1856 init_cmd_lists (void)
1858 max_user_call_depth
= 1024;
1862 show_info_verbose (struct ui_file
*file
, int from_tty
,
1863 struct cmd_list_element
*c
,
1867 fprintf_filtered (file
,
1868 _("Verbose printing of informational messages is %s.\n"),
1871 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1875 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1876 struct cmd_list_element
*c
, const char *value
)
1878 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1883 show_remote_debug (struct ui_file
*file
, int from_tty
,
1884 struct cmd_list_element
*c
, const char *value
)
1886 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1891 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1892 struct cmd_list_element
*c
, const char *value
)
1894 fprintf_filtered (file
,
1895 _("Timeout limit to wait for target to respond is %s.\n"),
1900 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1901 struct cmd_list_element
*c
, const char *value
)
1903 fprintf_filtered (file
,
1904 _("The max call depth for user-defined commands is %s.\n"),
1909 _initialize_cli_cmds (void)
1911 struct cmd_list_element
*c
;
1913 /* Define the classes of commands.
1914 They will appear in the help list in alphabetical order. */
1916 add_cmd ("internals", class_maintenance
, _("\
1917 Maintenance commands.\n\
1918 Some gdb commands are provided just for use by gdb maintainers.\n\
1919 These commands are subject to frequent change, and may not be as\n\
1920 well documented as user commands."),
1922 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
1923 add_cmd ("aliases", class_alias
,
1924 _("Aliases of other commands."), &cmdlist
);
1925 add_cmd ("user-defined", class_user
, _("\
1926 User-defined commands.\n\
1927 The commands in this class are those defined by the user.\n\
1928 Use the \"define\" command to define a command."), &cmdlist
);
1929 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
1931 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
1932 add_cmd ("files", class_files
, _("Specifying and examining files."),
1934 add_cmd ("breakpoints", class_breakpoint
,
1935 _("Making program stop at certain points."), &cmdlist
);
1936 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
1937 add_cmd ("stack", class_stack
, _("\
1938 Examining the stack.\n\
1939 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1940 counting from zero for the innermost (currently executing) frame.\n\n\
1941 At any time gdb identifies one frame as the \"selected\" frame.\n\
1942 Variable lookups are done with respect to the selected frame.\n\
1943 When the program being debugged stops, gdb selects the innermost frame.\n\
1944 The commands below can be used to select other frames by number or address."),
1946 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
1948 /* Define general commands. */
1950 add_com ("pwd", class_files
, pwd_command
, _("\
1951 Print working directory. This is used for your program as well."));
1953 c
= add_cmd ("cd", class_files
, cd_command
, _("\
1954 Set working directory to DIR for debugger.\n\
1955 The debugger's current working directory specifies where scripts and other\n\
1956 files that can be loaded by GDB are located.\n\
1957 In order to change the inferior's current working directory, the recommended\n\
1958 way is to use the \"set cwd\" command."), &cmdlist
);
1959 set_cmd_completer (c
, filename_completer
);
1961 add_com ("echo", class_support
, echo_command
, _("\
1962 Print a constant string. Give string as argument.\n\
1963 C escape sequences may be used in the argument.\n\
1964 No newline is added at the end of the argument;\n\
1965 use \"\\n\" if you want a newline to be printed.\n\
1966 Since leading and trailing whitespace are ignored in command arguments,\n\
1967 if you want to print some you must use \"\\\" before leading whitespace\n\
1968 to be printed or after trailing whitespace."));
1970 add_setshow_enum_cmd ("script-extension", class_support
,
1971 script_ext_enums
, &script_ext_mode
, _("\
1972 Set mode for script filename extension recognition."), _("\
1973 Show mode for script filename extension recognition."), _("\
1974 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1975 soft == evaluate script according to filename extension, fallback to GDB script"
1977 strict == evaluate script according to filename extension, error if not supported"
1980 show_script_ext_mode
,
1981 &setlist
, &showlist
);
1983 add_com ("quit", class_support
, quit_command
, _("\
1985 Usage: quit [EXPR]\n\
1986 The optional expression EXPR, if present, is evaluated and the result\n\
1987 used as GDB's exit code. The default is zero."));
1988 c
= add_com ("help", class_support
, help_command
,
1989 _("Print list of commands."));
1990 set_cmd_completer (c
, command_completer
);
1991 add_com_alias ("q", "quit", class_support
, 1);
1992 add_com_alias ("h", "help", class_support
, 1);
1994 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
1995 Set verbosity."), _("\
1996 Show verbosity."), NULL
,
1999 &setlist
, &showlist
);
2001 add_prefix_cmd ("history", class_support
, set_history
,
2002 _("Generic command for setting command history parameters."),
2003 &sethistlist
, "set history ", 0, &setlist
);
2004 add_prefix_cmd ("history", class_support
, show_history
,
2005 _("Generic command for showing command history parameters."),
2006 &showhistlist
, "show history ", 0, &showlist
);
2008 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2009 Set history expansion on command input."), _("\
2010 Show history expansion on command input."), _("\
2011 Without an argument, history expansion is enabled."),
2013 show_history_expansion_p
,
2014 &sethistlist
, &showhistlist
);
2016 add_prefix_cmd ("info", class_info
, info_command
, _("\
2017 Generic command for showing things about the program being debugged."),
2018 &infolist
, "info ", 0, &cmdlist
);
2019 add_com_alias ("i", "info", class_info
, 1);
2020 add_com_alias ("inf", "info", class_info
, 1);
2022 add_com ("complete", class_obscure
, complete_command
,
2023 _("List the completions for the rest of the line as a command."));
2025 add_prefix_cmd ("show", class_info
, show_command
, _("\
2026 Generic command for showing things about the debugger."),
2027 &showlist
, "show ", 0, &cmdlist
);
2028 /* Another way to get at the same thing. */
2029 add_info ("set", show_command
, _("Show all GDB settings."));
2031 c
= add_com ("with", class_vars
, with_command
, _("\
2032 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2033 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2034 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2035 With no COMMAND, repeats the last executed command.\n\
2037 SETTING is any setting you can change with the \"set\" subcommands.\n\
2039 with language pascal -- print obj\n\
2040 with print elements unlimited -- print obj\n\
2042 You can change multiple settings using nested with, and use\n\
2043 abbreviations for commands and/or values. E.g.:\n\
2044 w la p -- w p el u -- p obj"));
2045 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2046 add_com_alias ("w", "with", class_vars
, 1);
2048 add_cmd ("commands", no_set_class
, show_commands
, _("\
2049 Show the history of commands you typed.\n\
2050 You can supply a command number to start with, or a `+' to start after\n\
2051 the previous command number shown."),
2054 add_cmd ("version", no_set_class
, show_version
,
2055 _("Show what version of GDB this is."), &showlist
);
2057 add_cmd ("configuration", no_set_class
, show_configuration
,
2058 _("Show how GDB was configured at build time."), &showlist
);
2060 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2061 Set debugging of remote protocol."), _("\
2062 Show debugging of remote protocol."), _("\
2063 When enabled, each packet sent or received with the remote target\n\
2067 &setdebuglist
, &showdebuglist
);
2069 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2070 &remote_timeout
, _("\
2071 Set timeout limit to wait for target to respond."), _("\
2072 Show timeout limit to wait for target to respond."), _("\
2073 This value is used to set the time limit for gdb to wait for a response\n\
2076 show_remote_timeout
,
2077 &setlist
, &showlist
);
2079 add_prefix_cmd ("debug", no_class
, set_debug
,
2080 _("Generic command for setting gdb debugging flags"),
2081 &setdebuglist
, "set debug ", 0, &setlist
);
2083 add_prefix_cmd ("debug", no_class
, show_debug
,
2084 _("Generic command for showing gdb debugging flags"),
2085 &showdebuglist
, "show debug ", 0, &showlist
);
2087 c
= add_com ("shell", class_support
, shell_command
, _("\
2088 Execute the rest of the line as a shell command.\n\
2089 With no arguments, run an inferior shell."));
2090 set_cmd_completer (c
, filename_completer
);
2092 add_com_alias ("!", "shell", class_support
, 0);
2094 c
= add_com ("edit", class_files
, edit_command
, _("\
2095 Edit specified file or function.\n\
2096 With no argument, edits file containing most recent line listed.\n\
2097 Editing targets can be specified in these ways:\n\
2098 FILE:LINENUM, to edit at that line in that file,\n\
2099 FUNCTION, to edit at the beginning of that function,\n\
2100 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2101 *ADDRESS, to edit at the line containing that address.\n\
2102 Uses EDITOR environment variable contents as editor (or ex as default)."));
2104 c
->completer
= location_completer
;
2106 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2107 Send the output of a gdb command to a shell command.\n\
2108 Usage: | [COMMAND] | SHELL_COMMAND\n\
2109 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2110 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2111 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2113 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2115 The -d option indicates to use the string DELIM to separate COMMAND\n\
2116 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2117 case COMMAND contains a | character.\n\
2119 With no COMMAND, repeat the last executed command\n\
2120 and send its output to SHELL_COMMAND."));
2121 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2122 add_com_alias ("|", "pipe", class_support
, 0);
2124 add_com ("list", class_files
, list_command
, _("\
2125 List specified function or line.\n\
2126 With no argument, lists ten more lines after or around previous listing.\n\
2127 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2128 One argument specifies a line, and ten lines are listed around that line.\n\
2129 Two arguments with comma between specify starting and ending lines to list.\n\
2130 Lines can be specified in these ways:\n\
2131 LINENUM, to list around that line in current file,\n\
2132 FILE:LINENUM, to list around that line in that file,\n\
2133 FUNCTION, to list around beginning of that function,\n\
2134 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2135 *ADDRESS, to list around the line containing that address.\n\
2136 With two args, if one is empty, it stands for ten lines away from\n\
2139 By default, when a single location is given, display ten lines.\n\
2140 This can be changed using \"set listsize\", and the current value\n\
2141 can be shown using \"show listsize\"."));
2143 add_com_alias ("l", "list", class_files
, 1);
2146 add_com_alias ("file", "list", class_files
, 1);
2148 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2149 Disassemble a specified section of memory.\n\
2150 Default is the function surrounding the pc of the selected frame.\n\
2152 With a /m modifier, source lines are included (if available).\n\
2153 This view is \"source centric\": the output is in source line order,\n\
2154 regardless of any optimization that is present. Only the main source file\n\
2155 is displayed, not those of, e.g., any inlined functions.\n\
2156 This modifier hasn't proved useful in practice and is deprecated\n\
2159 With a /s modifier, source lines are included (if available).\n\
2160 This differs from /m in two important respects:\n\
2161 - the output is still in pc address order, and\n\
2162 - file names and contents for all relevant source files are displayed.\n\
2164 With a /r modifier, raw instructions in hex are included.\n\
2166 With a single argument, the function surrounding that address is dumped.\n\
2167 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2168 in the form of \"start,end\", or \"start,+length\".\n\
2170 Note that the address is interpreted as an expression, not as a location\n\
2171 like in the \"break\" command.\n\
2172 So, for example, if you want to disassemble function bar in file foo.c\n\
2173 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2174 set_cmd_completer (c
, location_completer
);
2176 c
= add_com ("make", class_support
, make_command
, _("\
2177 Run the ``make'' program using the rest of the line as arguments."));
2178 set_cmd_completer (c
, filename_completer
);
2179 add_cmd ("user", no_class
, show_user
, _("\
2180 Show definitions of non-python/scheme user defined commands.\n\
2181 Argument is the name of the user defined command.\n\
2182 With no argument, show definitions of all user defined commands."), &showlist
);
2183 add_com ("apropos", class_support
, apropos_command
, _("\
2184 Search for commands matching a REGEXP\n\
2185 Usage: apropos [-v] REGEXP\n\
2186 Flag -v indicates to produce a verbose output, showing full documentation\n\
2187 of the matching commands."));
2189 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2190 &max_user_call_depth
, _("\
2191 Set the max call depth for non-python/scheme user-defined commands."), _("\
2192 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2194 show_max_user_call_depth
,
2195 &setlist
, &showlist
);
2197 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2198 Set tracing of GDB CLI commands."), _("\
2199 Show state of GDB CLI command tracing."), _("\
2200 When 'on', each command is displayed as it is executed."),
2203 &setlist
, &showlist
);
2205 c
= add_com ("alias", class_support
, alias_command
, _("\
2206 Define a new command that is an alias of an existing command.\n\
2207 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2208 ALIAS is the name of the alias command to create.\n\
2209 COMMAND is the command being aliased to.\n\
2210 If \"-a\" is specified, the command is an abbreviation,\n\
2211 and will not appear in help command list output.\n\
2214 Make \"spe\" an alias of \"set print elements\":\n\
2215 alias spe = set print elements\n\
2216 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2217 alias -a set print elms = set print elements"));
2221 init_cli_cmds (void)
2223 struct cmd_list_element
*c
;
2224 char *source_help_text
;
2226 source_help_text
= xstrprintf (_("\
2227 Read commands from a file named FILE.\n\
2229 Usage: source [-s] [-v] FILE\n\
2230 -s: search for the script in the source search path,\n\
2231 even if FILE contains directories.\n\
2232 -v: each command in FILE is echoed as it is executed.\n\
2234 Note that the file \"%s\" is read automatically in this way\n\
2235 when GDB is started."), gdbinit
);
2236 c
= add_cmd ("source", class_support
, source_command
,
2237 source_help_text
, &cmdlist
);
2238 set_cmd_completer (c
, filename_completer
);