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 bool trace_commands
= false;
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
)
221 error (_("Missing arguments."));
223 const char *delim
= strstr (args
, "--");
224 const char *nested_cmd
= nullptr;
227 error (_("Missing setting before '--' delimiter"));
229 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
230 nested_cmd
= repeat_previous ();
232 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
233 /*allow_unknown=*/ 0,
234 /*ignore_help_classes=*/ 1);
235 gdb_assert (set_cmd
!= nullptr);
237 if (set_cmd
->var
== nullptr)
238 error (_("Cannot use this setting with the \"with\" command"));
240 std::string temp_value
241 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
243 if (nested_cmd
== nullptr)
244 nested_cmd
= skip_spaces (delim
+ 2);
246 std::string org_value
= get_setshow_command_value_string (set_cmd
);
248 /* Tweak the setting to the new temporary value. */
249 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
253 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
255 /* Execute the nested command. */
256 execute_command (nested_cmd
, from_tty
);
258 catch (const gdb_exception
&ex
)
260 /* Restore the setting and rethrow. If restoring the setting
261 throws, swallow the new exception and warn. There's nothing
262 else we can reasonably do. */
265 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
267 catch (const gdb_exception
&ex2
)
269 warning (_("Couldn't restore setting: %s"), ex2
.what ());
275 /* Restore the setting. */
276 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
279 /* See cli/cli-cmds.h. */
282 with_command_completer_1 (const char *set_cmd_prefix
,
283 completion_tracker
&tracker
,
286 tracker
.set_use_custom_word_point (true);
288 const char *delim
= strstr (text
, "--");
290 /* If we're still not past the "--" delimiter, complete the "with"
291 command as if it was a "set" command. */
294 || !isspace (delim
[-1])
295 || !(isspace (delim
[2]) || delim
[2] == '\0'))
297 std::string new_text
= std::string (set_cmd_prefix
) + text
;
298 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
299 complete_nested_command_line (tracker
, new_text
.c_str ());
303 /* We're past the "--" delimiter. Complete on the sub command. */
304 const char *nested_cmd
= skip_spaces (delim
+ 2);
305 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
306 complete_nested_command_line (tracker
, nested_cmd
);
309 /* The "with" command. */
312 with_command (const char *args
, int from_tty
)
314 with_command_1 ("set ", setlist
, args
, from_tty
);
317 /* "with" command completer. */
320 with_command_completer (struct cmd_list_element
*ignore
,
321 completion_tracker
&tracker
,
322 const char *text
, const char * /*word*/)
324 with_command_completer_1 ("set ", tracker
, text
);
328 /* Provide documentation on command or list given by COMMAND. FROM_TTY
332 help_command (const char *command
, int from_tty
)
334 help_cmd (command
, gdb_stdout
);
338 /* Note: The "complete" command is used by Emacs to implement completion.
339 [Is that why this function writes output with *_unfiltered?] */
342 complete_command (const char *arg
, int from_tty
)
346 if (max_completions
== 0)
348 /* Only print this for non-mi frontends. An MI frontend may not
349 be able to handle this. */
350 if (!current_uiout
->is_mi_like_p ())
352 printf_unfiltered (_("max-completions is zero,"
353 " completion is disabled.\n"));
361 int quote_char
= '\0';
364 completion_result result
= complete (arg
, &word
, "e_char
);
366 if (result
.number_matches
!= 0)
368 std::string
arg_prefix (arg
, word
- arg
);
370 if (result
.number_matches
== 1)
371 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
374 result
.sort_match_list ();
376 for (size_t i
= 0; i
< result
.number_matches
; i
++)
378 printf_unfiltered ("%s%s",
380 result
.match_list
[i
+ 1]);
382 printf_unfiltered ("%c", quote_char
);
383 printf_unfiltered ("\n");
387 if (result
.number_matches
== max_completions
)
389 /* ARG_PREFIX and WORD are included in the output so that emacs
390 will include the message in the output. */
391 printf_unfiltered (_("%s%s %s\n"),
392 arg_prefix
.c_str (), word
,
393 get_max_completions_reached_message ());
399 is_complete_command (struct cmd_list_element
*c
)
401 return cmd_cfunc_eq (c
, complete_command
);
405 show_version (const char *args
, int from_tty
)
407 print_gdb_version (gdb_stdout
, true);
408 printf_filtered ("\n");
412 show_configuration (const char *args
, int from_tty
)
414 print_gdb_configuration (gdb_stdout
);
417 /* Handle the quit command. */
420 quit_command (const char *args
, int from_tty
)
424 /* An optional expression may be used to cause gdb to terminate with
425 the value of that expression. */
428 struct value
*val
= parse_and_eval (args
);
430 exit_code
= (int) value_as_long (val
);
433 if (!quit_confirm ())
434 error (_("Not confirmed."));
436 query_if_trace_running (from_tty
);
438 quit_force (args
? &exit_code
: NULL
, from_tty
);
442 pwd_command (const char *args
, int from_tty
)
445 error (_("The \"pwd\" command does not take an argument: %s"), args
);
447 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
450 error (_("Error finding name of working directory: %s"),
451 safe_strerror (errno
));
453 if (strcmp (cwd
.get (), current_directory
) != 0)
454 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
455 current_directory
, cwd
.get ());
457 printf_unfiltered (_("Working directory %s.\n"), current_directory
);
461 cd_command (const char *dir
, int from_tty
)
464 /* Found something other than leading repetitions of "/..". */
468 /* If the new directory is absolute, repeat is a no-op; if relative,
469 repeat might be useful but is more likely to be a mistake. */
472 gdb::unique_xmalloc_ptr
<char> dir_holder
473 (tilde_expand (dir
!= NULL
? dir
: "~"));
474 dir
= dir_holder
.get ();
477 perror_with_name (dir
);
479 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
480 /* There's too much mess with DOSish names like "d:", "d:.",
481 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
482 simply get the canonicalized name of the current directory. */
483 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
488 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
490 /* Remove the trailing slash unless this is a root directory
491 (including a drive letter on non-Unix systems). */
492 if (!(len
== 1) /* "/" */
493 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
494 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
500 dir_holder
.reset (savestring (dir
, len
));
501 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
503 xfree (current_directory
);
504 current_directory
= dir_holder
.release ();
508 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
509 current_directory
= concat (current_directory
, dir_holder
.get (),
512 current_directory
= concat (current_directory
, SLASH_STRING
,
513 dir_holder
.get (), (char *) NULL
);
516 /* Now simplify any occurrences of `.' and `..' in the pathname. */
519 for (p
= current_directory
; *p
;)
521 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
522 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
523 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
524 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
525 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
529 /* Search backwards for the directory just before the "/.."
530 and obliterate it and the "/..". */
533 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
536 if (q
== current_directory
)
537 /* current_directory is
538 a relative pathname ("can't happen"--leave it alone). */
542 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
547 /* We are dealing with leading repetitions of "/..", for
548 example "/../..", which is the Mach super-root. */
558 forget_cached_source_info ();
561 pwd_command ((char *) 0, 1);
564 /* Show the current value of the 'script-extension' option. */
567 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
568 struct cmd_list_element
*c
, const char *value
)
570 fprintf_filtered (file
,
571 _("Script filename extension recognition is \"%s\".\n"),
575 /* Try to open SCRIPT_FILE.
576 If successful, the full path name is stored in *FULL_PATHP,
577 and the stream is returned.
578 If not successful, return NULL; errno is set for the last file
581 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
582 search for it in the source search path. */
584 gdb::optional
<open_script
>
585 find_and_open_script (const char *script_file
, int search_path
)
588 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
589 gdb::optional
<open_script
> opened
;
591 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
594 search_flags
|= OPF_SEARCH_IN_PATH
;
596 /* Search for and open 'file' on the search path used for source
597 files. Put the full location in *FULL_PATHP. */
598 gdb::unique_xmalloc_ptr
<char> full_path
;
599 fd
= openp (source_path
, search_flags
,
600 file
.get (), O_RDONLY
, &full_path
);
605 FILE *result
= fdopen (fd
, FOPEN_RT
);
608 int save_errno
= errno
;
614 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
619 /* Load script FILE, which has already been opened as STREAM.
620 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
621 This is provided as FILE may have been found via the source search path.
622 An important thing to note here is that FILE may be a symlink to a file
623 with a different or non-existing suffix, and thus one cannot infer the
624 extension language from FILE_TO_OPEN. */
627 source_script_from_stream (FILE *stream
, const char *file
,
628 const char *file_to_open
)
630 if (script_ext_mode
!= script_ext_off
)
632 const struct extension_language_defn
*extlang
633 = get_ext_lang_of_file (file
);
637 if (ext_lang_present_p (extlang
))
639 script_sourcer_func
*sourcer
640 = ext_lang_script_sourcer (extlang
);
642 gdb_assert (sourcer
!= NULL
);
643 sourcer (extlang
, stream
, file_to_open
);
646 else if (script_ext_mode
== script_ext_soft
)
648 /* Assume the file is a gdb script.
649 This is handled below. */
652 throw_ext_lang_unsupported (extlang
);
656 script_from_file (stream
, file
);
659 /* Worker to perform the "source" command.
661 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
662 search for it in the source search path. */
665 source_script_with_search (const char *file
, int from_tty
, int search_path
)
668 if (file
== NULL
|| *file
== 0)
669 error (_("source command requires file name of file to source."));
671 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
674 /* The script wasn't found, or was otherwise inaccessible.
675 If the source command was invoked interactively, throw an
676 error. Otherwise (e.g. if it was invoked by a script),
677 just emit a warning, rather than cause an error. */
679 perror_with_name (file
);
682 perror_warning_with_name (file
);
687 /* The python support reopens the file, so we need to pass full_path here
688 in case the file was found on the search path. It's useful to do this
689 anyway so that error messages show the actual file used. But only do
690 this if we (may have) used search_path, as printing the full path in
691 errors for the non-search case can be more noise than signal. */
692 source_script_from_stream (opened
->stream
.get (), file
,
693 search_path
? opened
->full_path
.get () : file
);
696 /* Wrapper around source_script_with_search to export it to main.c
697 for use in loading .gdbinit scripts. */
700 source_script (const char *file
, int from_tty
)
702 source_script_with_search (file
, from_tty
, 0);
706 source_command (const char *args
, int from_tty
)
708 const char *file
= args
;
711 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
713 /* -v causes the source command to run in verbose mode.
714 -s causes the file to be searched in the source search path,
715 even if the file name contains a '/'.
716 We still have to be able to handle filenames with spaces in a
717 backward compatible way, so buildargv is not appropriate. */
721 while (args
[0] != '\0')
723 /* Make sure leading white space does not break the
725 args
= skip_spaces (args
);
730 if (args
[1] == 'v' && isspace (args
[2]))
734 /* Skip passed -v. */
737 else if (args
[1] == 's' && isspace (args
[2]))
741 /* Skip passed -s. */
748 file
= skip_spaces (args
);
751 source_script_with_search (file
, from_tty
, search_path
);
756 echo_command (const char *text
, int from_tty
)
758 const char *p
= text
;
762 while ((c
= *p
++) != '\0')
766 /* \ at end of argument is used after spaces
767 so they won't be lost. */
771 c
= parse_escape (get_current_arch (), &p
);
773 printf_filtered ("%c", c
);
776 printf_filtered ("%c", c
);
779 reset_terminal_style (gdb_stdout
);
781 /* Force this output to appear now. */
783 gdb_flush (gdb_stdout
);
786 /* Sets the last launched shell command convenience variables based on
790 exit_status_set_internal_vars (int exit_status
)
792 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
793 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
795 clear_internalvar (var_code
);
796 clear_internalvar (var_signal
);
797 if (WIFEXITED (exit_status
))
798 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
799 else if (WIFSIGNALED (exit_status
))
800 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
802 warning (_("unexpected shell command exit status %d"), exit_status
);
806 shell_escape (const char *arg
, int from_tty
)
808 #if defined(CANT_FORK) || \
809 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
810 /* If ARG is NULL, they want an inferior shell, but `system' just
811 reports if the shell is available when passed a NULL arg. */
812 int rc
= system (arg
? arg
: "");
815 arg
= "inferior shell";
818 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
819 safe_strerror (errno
));
821 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
823 /* Make sure to return to the directory GDB thinks it is, in case
824 the shell command we just ran changed it. */
825 chdir (current_directory
);
826 exit_status_set_internal_vars (rc
);
828 #else /* Can fork. */
831 if ((pid
= vfork ()) == 0)
833 const char *p
, *user_shell
= get_shell ();
837 /* Get the name of the shell for arg0. */
838 p
= lbasename (user_shell
);
841 execl (user_shell
, p
, (char *) 0);
843 execl (user_shell
, p
, "-c", arg
, (char *) 0);
845 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
846 safe_strerror (errno
));
851 waitpid (pid
, &status
, 0);
853 error (_("Fork failed"));
854 exit_status_set_internal_vars (status
);
855 #endif /* Can fork. */
858 /* Implementation of the "shell" command. */
861 shell_command (const char *arg
, int from_tty
)
863 shell_escape (arg
, from_tty
);
867 edit_command (const char *arg
, int from_tty
)
869 struct symtab_and_line sal
;
875 /* Pull in the current default source line if necessary. */
878 set_default_source_symtab_and_line ();
879 sal
= get_current_source_symtab_and_line ();
882 /* Bare "edit" edits file with present line. */
887 error (_("No default source file yet."));
888 sal
.line
+= get_lines_to_list () / 2;
894 /* Now should only be one argument -- decode it in SAL. */
896 event_location_up location
= string_to_event_location (&arg1
,
898 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
899 DECODE_LINE_LIST_MODE
,
908 if (sals
.size () > 1)
910 ambiguous_line_spec (sals
,
911 _("Specified line is ambiguous:\n"));
918 error (_("Junk at end of line specification."));
920 /* If line was specified by address, first print exactly which
921 line, and which file. In this case, sal.symtab == 0 means
922 address is outside of all known source files, not that user
923 failed to give a filename. */
926 struct gdbarch
*gdbarch
;
929 error (_("No source file for address %s."),
930 paddress (get_current_arch (), sal
.pc
));
932 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
933 sym
= find_pc_function (sal
.pc
);
935 printf_filtered ("%s is in %s (%s:%d).\n",
936 paddress (gdbarch
, sal
.pc
),
937 SYMBOL_PRINT_NAME (sym
),
938 symtab_to_filename_for_display (sal
.symtab
),
941 printf_filtered ("%s is at %s:%d.\n",
942 paddress (gdbarch
, sal
.pc
),
943 symtab_to_filename_for_display (sal
.symtab
),
947 /* If what was given does not imply a symtab, it must be an
948 undebuggable symbol which means no source code. */
951 error (_("No line number known for %s."), arg
);
954 if ((editor
= getenv ("EDITOR")) == NULL
)
957 fn
= symtab_to_fullname (sal
.symtab
);
959 /* Quote the file name, in case it has whitespace or other special
961 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
962 shell_escape (p
, from_tty
);
966 /* The options for the "pipe" command. */
971 char *delimiter
= nullptr;
979 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
981 gdb::option::string_option_def
<pipe_cmd_opts
> {
983 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
985 N_("Indicates to use the specified delimiter string to separate\n\
986 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
987 case COMMAND contains a | character."),
992 /* Create an option_def_group for the "pipe" command's options, with
995 static inline gdb::option::option_def_group
996 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
998 return {{pipe_cmd_option_defs
}, opts
};
1001 /* Implementation of the "pipe" command. */
1004 pipe_command (const char *arg
, int from_tty
)
1008 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1009 gdb::option::process_options
1010 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1012 const char *delim
= "|";
1013 if (opts
.delimiter
!= nullptr)
1014 delim
= opts
.delimiter
;
1016 const char *command
= arg
;
1017 if (command
== nullptr)
1018 error (_("Missing COMMAND"));
1020 arg
= strstr (arg
, delim
);
1023 error (_("Missing delimiter before SHELL_COMMAND"));
1025 std::string
gdb_cmd (command
, arg
- command
);
1027 arg
+= strlen (delim
); /* Skip the delimiter. */
1029 if (gdb_cmd
.empty ())
1030 gdb_cmd
= repeat_previous ();
1032 const char *shell_command
= skip_spaces (arg
);
1033 if (*shell_command
== '\0')
1034 error (_("Missing SHELL_COMMAND"));
1036 FILE *to_shell_command
= popen (shell_command
, "w");
1038 if (to_shell_command
== nullptr)
1039 error (_("Error launching \"%s\""), shell_command
);
1043 stdio_file
pipe_file (to_shell_command
);
1045 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1049 pclose (to_shell_command
);
1053 int exit_status
= pclose (to_shell_command
);
1055 if (exit_status
< 0)
1056 error (_("shell command \"%s\" failed: %s"), shell_command
,
1057 safe_strerror (errno
));
1058 exit_status_set_internal_vars (exit_status
);
1061 /* Completer for the pipe command. */
1064 pipe_command_completer (struct cmd_list_element
*ignore
,
1065 completion_tracker
&tracker
,
1066 const char *text
, const char *word_ignored
)
1070 const char *org_text
= text
;
1071 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1072 if (gdb::option::complete_options
1073 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1076 const char *delimiter
= "|";
1077 if (opts
.delimiter
!= nullptr)
1078 delimiter
= opts
.delimiter
;
1080 /* Check if we're past option values already. */
1081 if (text
> org_text
&& !isspace (text
[-1]))
1084 const char *delim
= strstr (text
, delimiter
);
1086 /* If we're still not past the delimiter, complete the gdb
1088 if (delim
== nullptr || delim
== text
)
1090 complete_nested_command_line (tracker
, text
);
1094 /* We're past the delimiter. What follows is a shell command, which
1095 we don't know how to complete. */
1099 list_command (const char *arg
, int from_tty
)
1106 int linenum_beg
= 0;
1109 /* Pull in the current default source line if necessary. */
1110 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1112 set_default_source_symtab_and_line ();
1113 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1115 /* If this is the first "list" since we've set the current
1116 source line, center the listing around that line. */
1117 if (get_first_line_listed () == 0)
1121 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1123 /* A small special case --- if listing backwards, and we
1124 should list only one line, list the preceding line,
1125 instead of the exact line we've just shown after e.g.,
1126 stopping for a breakpoint. */
1127 if (arg
!= NULL
&& arg
[0] == '-'
1128 && get_lines_to_list () == 1 && first
> 1)
1131 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1134 /* "l" or "l +" lists next ten lines. */
1135 else if (arg
== NULL
|| arg
[0] == '+')
1136 print_source_lines (cursal
.symtab
,
1137 source_lines_range (cursal
.line
), 0);
1139 /* "l -" lists previous ten lines, the ones before the ten just
1141 else if (arg
[0] == '-')
1143 if (get_first_line_listed () == 1)
1144 error (_("Already at the start of %s."),
1145 symtab_to_filename_for_display (cursal
.symtab
));
1146 source_lines_range
range (get_first_line_listed (),
1147 source_lines_range::BACKWARD
);
1148 print_source_lines (cursal
.symtab
, range
, 0);
1154 /* Now if there is only one argument, decode it in SAL
1156 If there are two arguments, decode them in SAL and SAL_END
1157 and clear NO_END; however, if one of the arguments is blank,
1158 set DUMMY_BEG or DUMMY_END to record that fact. */
1160 if (!have_full_symbols () && !have_partial_symbols ())
1161 error (_("No symbol table is loaded. Use the \"file\" command."));
1163 std::vector
<symtab_and_line
> sals
;
1164 symtab_and_line sal
, sal_end
;
1171 event_location_up location
= string_to_event_location (&arg1
,
1173 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1185 /* Record whether the BEG arg is all digits. */
1187 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1188 linenum_beg
= (p
== arg1
);
1190 /* Save the range of the first argument, in case we need to let the
1191 user know it was ambiguous. */
1192 const char *beg
= arg
;
1193 size_t beg_len
= arg1
- beg
;
1195 while (*arg1
== ' ' || *arg1
== '\t')
1200 if (sals
.size () > 1)
1202 ambiguous_line_spec (sals
,
1203 _("Specified first line '%.*s' is ambiguous:\n"),
1204 (int) beg_len
, beg
);
1208 while (*arg1
== ' ' || *arg1
== '\t')
1214 /* Save the last argument, in case we need to let the user
1215 know it was ambiguous. */
1216 const char *end_arg
= arg1
;
1218 event_location_up location
1219 = string_to_event_location (&arg1
, current_language
);
1221 std::vector
<symtab_and_line
> sals_end
1223 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1225 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1226 NULL
, sal
.symtab
, sal
.line
));
1228 filter_sals (sals_end
);
1229 if (sals_end
.empty ())
1231 if (sals_end
.size () > 1)
1233 ambiguous_line_spec (sals_end
,
1234 _("Specified last line '%s' is ambiguous:\n"),
1238 sal_end
= sals_end
[0];
1243 error (_("Junk at end of line specification."));
1245 if (!no_end
&& !dummy_beg
&& !dummy_end
1246 && sal
.symtab
!= sal_end
.symtab
)
1247 error (_("Specified first and last lines are in different files."));
1248 if (dummy_beg
&& dummy_end
)
1249 error (_("Two empty args do not say what lines to list."));
1251 /* If line was specified by address,
1252 first print exactly which line, and which file.
1254 In this case, sal.symtab == 0 means address is outside of all
1255 known source files, not that user failed to give a filename. */
1258 struct gdbarch
*gdbarch
;
1260 if (sal
.symtab
== 0)
1261 error (_("No source file for address %s."),
1262 paddress (get_current_arch (), sal
.pc
));
1264 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1265 sym
= find_pc_function (sal
.pc
);
1267 printf_filtered ("%s is in %s (%s:%d).\n",
1268 paddress (gdbarch
, sal
.pc
),
1269 SYMBOL_PRINT_NAME (sym
),
1270 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1272 printf_filtered ("%s is at %s:%d.\n",
1273 paddress (gdbarch
, sal
.pc
),
1274 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1277 /* If line was not specified by just a line number, and it does not
1278 imply a symtab, it must be an undebuggable symbol which means no
1281 if (!linenum_beg
&& sal
.symtab
== 0)
1282 error (_("No line number known for %s."), arg
);
1284 /* If this command is repeated with RET,
1285 turn it into the no-arg variant. */
1288 set_repeat_arguments ("");
1290 if (dummy_beg
&& sal_end
.symtab
== 0)
1291 error (_("No default source file yet. Do \"help list\"."));
1294 source_lines_range
range (sal_end
.line
+ 1,
1295 source_lines_range::BACKWARD
);
1296 print_source_lines (sal_end
.symtab
, range
, 0);
1298 else if (sal
.symtab
== 0)
1299 error (_("No default source file yet. Do \"help list\"."));
1302 for (int i
= 0; i
< sals
.size (); i
++)
1305 int first_line
= sal
.line
- get_lines_to_list () / 2;
1308 if (sals
.size () > 1)
1309 print_sal_location (sal
);
1310 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1314 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1316 print_source_lines (sal
.symtab
,
1317 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1321 /* Subroutine of disassemble_command to simplify it.
1322 Perform the disassembly.
1323 NAME is the name of the function if known, or NULL.
1324 [LOW,HIGH) are the range of addresses to disassemble.
1325 BLOCK is the block to disassemble; it needs to be provided
1326 when non-contiguous blocks are disassembled; otherwise
1328 MIXED is non-zero to print source with the assembler. */
1331 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1332 CORE_ADDR low
, CORE_ADDR high
,
1333 const struct block
*block
,
1334 gdb_disassembly_flags flags
)
1337 if (!tui_is_window_visible (DISASSEM_WIN
))
1340 printf_filtered ("Dump of assembler code ");
1342 printf_filtered ("for function %s:\n", name
);
1343 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1346 printf_filtered ("from %s to %s:\n",
1347 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1349 /* Dump the specified range. */
1350 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1354 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1356 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1357 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1358 printf_filtered (_("Address range %s to %s:\n"),
1359 paddress (gdbarch
, range_low
),
1360 paddress (gdbarch
, range_high
));
1361 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1362 range_low
, range_high
);
1365 printf_filtered ("End of assembler dump.\n");
1370 tui_show_assembly (gdbarch
, low
);
1375 /* Subroutine of disassemble_command to simplify it.
1376 Print a disassembly of the current function according to FLAGS. */
1379 disassemble_current_function (gdb_disassembly_flags flags
)
1381 struct frame_info
*frame
;
1382 struct gdbarch
*gdbarch
;
1383 CORE_ADDR low
, high
, pc
;
1385 const struct block
*block
;
1387 frame
= get_selected_frame (_("No frame selected."));
1388 gdbarch
= get_frame_arch (frame
);
1389 pc
= get_frame_address_in_block (frame
);
1390 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1391 error (_("No function contains program counter for selected frame."));
1393 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1396 /* FIXME: cagney/2004-02-07: This should be an observer. */
1397 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1399 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1401 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1404 /* Dump a specified section of assembly code.
1408 - dump the assembly code for the function of the current pc
1409 disassemble [/mrs] addr
1410 - dump the assembly code for the function at ADDR
1411 disassemble [/mrs] low,high
1412 disassemble [/mrs] low,+length
1413 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1415 A /m modifier will include source code with the assembly in a
1416 "source centric" view. This view lists only the file of the first insn,
1417 even if other source files are involved (e.g., inlined functions), and
1418 the output is in source order, even with optimized code. This view is
1419 considered deprecated as it hasn't been useful in practice.
1421 A /r modifier will include raw instructions in hex with the assembly.
1423 A /s modifier will include source code with the assembly, like /m, with
1424 two important differences:
1425 1) The output is still in pc address order.
1426 2) File names and contents for all relevant source files are displayed. */
1429 disassemble_command (const char *arg
, int from_tty
)
1431 struct gdbarch
*gdbarch
= get_current_arch ();
1432 CORE_ADDR low
, high
;
1435 gdb_disassembly_flags flags
;
1437 const struct block
*block
= nullptr;
1448 error (_("Missing modifier."));
1450 while (*p
&& ! isspace (*p
))
1455 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1458 flags
|= DISASSEMBLY_RAW_INSN
;
1461 flags
|= DISASSEMBLY_SOURCE
;
1464 error (_("Invalid disassembly modifier."));
1468 p
= skip_spaces (p
);
1471 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1472 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1473 error (_("Cannot specify both /m and /s."));
1477 flags
|= DISASSEMBLY_OMIT_FNAME
;
1478 disassemble_current_function (flags
);
1482 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1488 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1489 error (_("No function contains specified address."));
1491 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1494 /* FIXME: cagney/2004-02-07: This should be an observer. */
1495 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1497 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1498 flags
|= DISASSEMBLY_OMIT_FNAME
;
1502 /* Two arguments. */
1505 p
= skip_spaces (p
);
1511 high
= parse_and_eval_address (p
);
1516 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1520 make_command (const char *arg
, int from_tty
)
1523 shell_escape ("make", from_tty
);
1526 std::string cmd
= std::string ("make ") + arg
;
1528 shell_escape (cmd
.c_str (), from_tty
);
1533 show_user (const char *args
, int from_tty
)
1535 struct cmd_list_element
*c
;
1536 extern struct cmd_list_element
*cmdlist
;
1540 const char *comname
= args
;
1542 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1543 if (!cli_user_command_p (c
))
1544 error (_("Not a user command."));
1545 show_user_1 (c
, "", args
, gdb_stdout
);
1549 for (c
= cmdlist
; c
; c
= c
->next
)
1551 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1552 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1557 /* Search through names of commands and documentations for a certain
1558 regular expression. */
1561 apropos_command (const char *arg
, int from_tty
)
1563 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1565 if (arg
== NULL
|| *arg
== '\0')
1566 error (_("REGEXP string is empty"));
1568 compiled_regex
pattern (arg
, REG_ICASE
,
1569 _("Error in regular expression"));
1571 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1574 /* Subroutine of alias_command to simplify it.
1575 Return the first N elements of ARGV flattened back to a string
1576 with a space separating each element.
1577 ARGV may not be NULL.
1578 This does not take care of quoting elements in case they contain spaces
1582 argv_to_string (char **argv
, int n
)
1587 gdb_assert (argv
!= NULL
);
1588 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1590 for (i
= 0; i
< n
; ++i
)
1600 /* Subroutine of alias_command to simplify it.
1601 Return true if COMMAND exists, unambiguously. Otherwise false. */
1604 valid_command_p (const char *command
)
1606 struct cmd_list_element
*c
;
1608 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1610 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1613 /* This is the slightly tricky part.
1614 lookup_cmd_1 will return a pointer to the last part of COMMAND
1615 to match, leaving COMMAND pointing at the remainder. */
1616 while (*command
== ' ' || *command
== '\t')
1618 return *command
== '\0';
1621 /* Called when "alias" was incorrectly used. */
1624 alias_usage_error (void)
1626 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1629 /* Make an alias of an existing command. */
1632 alias_command (const char *args
, int from_tty
)
1634 int i
, alias_argc
, command_argc
;
1635 int abbrev_flag
= 0;
1637 const char *alias
, *command
;
1639 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1640 alias_usage_error ();
1642 equals
= strchr (args
, '=');
1643 std::string
args2 (args
, equals
- args
);
1645 gdb_argv
built_alias_argv (args2
.c_str ());
1646 gdb_argv
command_argv (equals
+ 1);
1648 char **alias_argv
= built_alias_argv
.get ();
1649 while (alias_argv
[0] != NULL
)
1651 if (strcmp (alias_argv
[0], "-a") == 0)
1656 else if (strcmp (alias_argv
[0], "--") == 0)
1665 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1666 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1667 alias_usage_error ();
1669 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1671 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1674 error (_("Invalid command name: %s"), alias_argv
[i
]);
1676 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1680 alias_argc
= countargv (alias_argv
);
1681 command_argc
= command_argv
.count ();
1683 /* COMMAND must exist.
1684 Reconstruct the command to remove any extraneous spaces,
1685 for better error messages. */
1686 std::string
command_string (argv_to_string (command_argv
.get (),
1688 command
= command_string
.c_str ();
1689 if (! valid_command_p (command
))
1690 error (_("Invalid command to alias to: %s"), command
);
1692 /* ALIAS must not exist. */
1693 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1694 alias
= alias_string
.c_str ();
1695 if (valid_command_p (alias
))
1696 error (_("Alias already exists: %s"), alias
);
1698 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1699 Example: alias spe = set print elements
1701 Otherwise ALIAS and COMMAND must have the same number of words,
1702 and every word except the last must identify the same prefix command;
1703 and the last word of ALIAS is made an alias of the last word of COMMAND.
1704 Example: alias set print elms = set pr elem
1705 Note that unambiguous abbreviations are allowed. */
1707 if (alias_argc
== 1)
1709 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1710 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1715 const char *alias_prefix
, *command_prefix
;
1716 struct cmd_list_element
*c_alias
, *c_command
;
1718 if (alias_argc
!= command_argc
)
1719 error (_("Mismatched command length between ALIAS and COMMAND."));
1721 /* Create copies of ALIAS and COMMAND without the last word,
1722 and use that to verify the leading elements give the same
1724 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1726 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1728 alias_prefix
= alias_prefix_string
.c_str ();
1729 command_prefix
= command_prefix_string
.c_str ();
1731 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1732 /* We've already tried to look up COMMAND. */
1733 gdb_assert (c_command
!= NULL
1734 && c_command
!= (struct cmd_list_element
*) -1);
1735 gdb_assert (c_command
->prefixlist
!= NULL
);
1736 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1737 if (c_alias
!= c_command
)
1738 error (_("ALIAS and COMMAND prefixes do not match."));
1740 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1741 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1742 command_argv
[command_argc
- 1],
1743 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1747 /* Print the file / line number / symbol name of the location
1748 specified by SAL. */
1751 print_sal_location (const symtab_and_line
&sal
)
1753 scoped_restore_current_program_space restore_pspace
;
1754 set_current_program_space (sal
.pspace
);
1756 const char *sym_name
= NULL
;
1757 if (sal
.symbol
!= NULL
)
1758 sym_name
= SYMBOL_PRINT_NAME (sal
.symbol
);
1759 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1760 symtab_to_filename_for_display (sal
.symtab
),
1761 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1764 /* Print a list of files and line numbers which a user may choose from
1765 in order to list a function which was specified ambiguously (as
1766 with `list classname::overloadedfuncname', for example). The SALS
1767 array provides the filenames and line numbers. FORMAT is a
1768 printf-style format string used to tell the user what was
1772 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1773 const char *format
, ...)
1776 va_start (ap
, format
);
1777 vprintf_filtered (format
, ap
);
1780 for (const auto &sal
: sals
)
1781 print_sal_location (sal
);
1784 /* Comparison function for filter_sals. Returns a qsort-style
1788 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1790 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1791 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1799 else if (dirb
== NULL
)
1806 r
= filename_cmp (dira
, dirb
);
1811 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1815 if (sala
.line
< salb
.line
)
1817 return sala
.line
== salb
.line
? 0 : 1;
1820 /* Remove any SALs that do not match the current program space, or
1821 which appear to be "file:line" duplicates. */
1824 filter_sals (std::vector
<symtab_and_line
> &sals
)
1826 /* Remove SALs that do not match. */
1827 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1828 [&] (const symtab_and_line
&sal
)
1829 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1832 std::sort (sals
.begin (), from
,
1833 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1834 { return cmp_symtabs (sala
, salb
) < 0; });
1836 from
= std::unique (sals
.begin (), from
,
1837 [&] (const symtab_and_line
&sala
,
1838 const symtab_and_line
&salb
)
1839 { return cmp_symtabs (sala
, salb
) == 0; });
1841 sals
.erase (from
, sals
.end ());
1845 set_debug (const char *arg
, int from_tty
)
1847 printf_unfiltered (_("\"set debug\" must be followed by "
1848 "the name of a debug subcommand.\n"));
1849 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1853 show_debug (const char *args
, int from_tty
)
1855 cmd_show_list (showdebuglist
, from_tty
, "");
1859 init_cmd_lists (void)
1861 max_user_call_depth
= 1024;
1865 show_info_verbose (struct ui_file
*file
, int from_tty
,
1866 struct cmd_list_element
*c
,
1870 fprintf_filtered (file
,
1871 _("Verbose printing of informational messages is %s.\n"),
1874 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1878 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1879 struct cmd_list_element
*c
, const char *value
)
1881 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1886 show_remote_debug (struct ui_file
*file
, int from_tty
,
1887 struct cmd_list_element
*c
, const char *value
)
1889 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1894 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1895 struct cmd_list_element
*c
, const char *value
)
1897 fprintf_filtered (file
,
1898 _("Timeout limit to wait for target to respond is %s.\n"),
1903 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1904 struct cmd_list_element
*c
, const char *value
)
1906 fprintf_filtered (file
,
1907 _("The max call depth for user-defined commands is %s.\n"),
1912 _initialize_cli_cmds (void)
1914 struct cmd_list_element
*c
;
1916 /* Define the classes of commands.
1917 They will appear in the help list in alphabetical order. */
1919 add_cmd ("internals", class_maintenance
, _("\
1920 Maintenance commands.\n\
1921 Some gdb commands are provided just for use by gdb maintainers.\n\
1922 These commands are subject to frequent change, and may not be as\n\
1923 well documented as user commands."),
1925 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
1926 add_cmd ("aliases", class_alias
,
1927 _("Aliases of other commands."), &cmdlist
);
1928 add_cmd ("user-defined", class_user
, _("\
1929 User-defined commands.\n\
1930 The commands in this class are those defined by the user.\n\
1931 Use the \"define\" command to define a command."), &cmdlist
);
1932 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
1934 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
1935 add_cmd ("files", class_files
, _("Specifying and examining files."),
1937 add_cmd ("breakpoints", class_breakpoint
,
1938 _("Making program stop at certain points."), &cmdlist
);
1939 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
1940 add_cmd ("stack", class_stack
, _("\
1941 Examining the stack.\n\
1942 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1943 counting from zero for the innermost (currently executing) frame.\n\n\
1944 At any time gdb identifies one frame as the \"selected\" frame.\n\
1945 Variable lookups are done with respect to the selected frame.\n\
1946 When the program being debugged stops, gdb selects the innermost frame.\n\
1947 The commands below can be used to select other frames by number or address."),
1949 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
1951 /* Define general commands. */
1953 add_com ("pwd", class_files
, pwd_command
, _("\
1954 Print working directory.\n\
1955 This is used for your program as well."));
1957 c
= add_cmd ("cd", class_files
, cd_command
, _("\
1958 Set working directory to DIR for debugger.\n\
1959 The debugger's current working directory specifies where scripts and other\n\
1960 files that can be loaded by GDB are located.\n\
1961 In order to change the inferior's current working directory, the recommended\n\
1962 way is to use the \"set cwd\" command."), &cmdlist
);
1963 set_cmd_completer (c
, filename_completer
);
1965 add_com ("echo", class_support
, echo_command
, _("\
1966 Print a constant string. Give string as argument.\n\
1967 C escape sequences may be used in the argument.\n\
1968 No newline is added at the end of the argument;\n\
1969 use \"\\n\" if you want a newline to be printed.\n\
1970 Since leading and trailing whitespace are ignored in command arguments,\n\
1971 if you want to print some you must use \"\\\" before leading whitespace\n\
1972 to be printed or after trailing whitespace."));
1974 add_setshow_enum_cmd ("script-extension", class_support
,
1975 script_ext_enums
, &script_ext_mode
, _("\
1976 Set mode for script filename extension recognition."), _("\
1977 Show mode for script filename extension recognition."), _("\
1978 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1979 soft == evaluate script according to filename extension, fallback to GDB script"
1981 strict == evaluate script according to filename extension, error if not supported"
1984 show_script_ext_mode
,
1985 &setlist
, &showlist
);
1987 add_com ("quit", class_support
, quit_command
, _("\
1989 Usage: quit [EXPR]\n\
1990 The optional expression EXPR, if present, is evaluated and the result\n\
1991 used as GDB's exit code. The default is zero."));
1992 c
= add_com ("help", class_support
, help_command
,
1993 _("Print list of commands."));
1994 set_cmd_completer (c
, command_completer
);
1995 add_com_alias ("q", "quit", class_support
, 1);
1996 add_com_alias ("h", "help", class_support
, 1);
1998 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
1999 Set verbosity."), _("\
2000 Show verbosity."), NULL
,
2003 &setlist
, &showlist
);
2005 add_prefix_cmd ("history", class_support
, set_history
,
2006 _("Generic command for setting command history parameters."),
2007 &sethistlist
, "set history ", 0, &setlist
);
2008 add_prefix_cmd ("history", class_support
, show_history
,
2009 _("Generic command for showing command history parameters."),
2010 &showhistlist
, "show history ", 0, &showlist
);
2012 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2013 Set history expansion on command input."), _("\
2014 Show history expansion on command input."), _("\
2015 Without an argument, history expansion is enabled."),
2017 show_history_expansion_p
,
2018 &sethistlist
, &showhistlist
);
2020 add_prefix_cmd ("info", class_info
, info_command
, _("\
2021 Generic command for showing things about the program being debugged."),
2022 &infolist
, "info ", 0, &cmdlist
);
2023 add_com_alias ("i", "info", class_info
, 1);
2024 add_com_alias ("inf", "info", class_info
, 1);
2026 add_com ("complete", class_obscure
, complete_command
,
2027 _("List the completions for the rest of the line as a command."));
2029 add_prefix_cmd ("show", class_info
, show_command
, _("\
2030 Generic command for showing things about the debugger."),
2031 &showlist
, "show ", 0, &cmdlist
);
2032 /* Another way to get at the same thing. */
2033 add_info ("set", show_command
, _("Show all GDB settings."));
2035 c
= add_com ("with", class_vars
, with_command
, _("\
2036 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2037 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2038 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2039 With no COMMAND, repeats the last executed command.\n\
2041 SETTING is any setting you can change with the \"set\" subcommands.\n\
2043 with language pascal -- print obj\n\
2044 with print elements unlimited -- print obj\n\
2046 You can change multiple settings using nested with, and use\n\
2047 abbreviations for commands and/or values. E.g.:\n\
2048 w la p -- w p el u -- p obj"));
2049 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2050 add_com_alias ("w", "with", class_vars
, 1);
2052 add_cmd ("commands", no_set_class
, show_commands
, _("\
2053 Show the history of commands you typed.\n\
2054 You can supply a command number to start with, or a `+' to start after\n\
2055 the previous command number shown."),
2058 add_cmd ("version", no_set_class
, show_version
,
2059 _("Show what version of GDB this is."), &showlist
);
2061 add_cmd ("configuration", no_set_class
, show_configuration
,
2062 _("Show how GDB was configured at build time."), &showlist
);
2064 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2065 Set debugging of remote protocol."), _("\
2066 Show debugging of remote protocol."), _("\
2067 When enabled, each packet sent or received with the remote target\n\
2071 &setdebuglist
, &showdebuglist
);
2073 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2074 &remote_timeout
, _("\
2075 Set timeout limit to wait for target to respond."), _("\
2076 Show timeout limit to wait for target to respond."), _("\
2077 This value is used to set the time limit for gdb to wait for a response\n\
2080 show_remote_timeout
,
2081 &setlist
, &showlist
);
2083 add_prefix_cmd ("debug", no_class
, set_debug
,
2084 _("Generic command for setting gdb debugging flags."),
2085 &setdebuglist
, "set debug ", 0, &setlist
);
2087 add_prefix_cmd ("debug", no_class
, show_debug
,
2088 _("Generic command for showing gdb debugging flags."),
2089 &showdebuglist
, "show debug ", 0, &showlist
);
2091 c
= add_com ("shell", class_support
, shell_command
, _("\
2092 Execute the rest of the line as a shell command.\n\
2093 With no arguments, run an inferior shell."));
2094 set_cmd_completer (c
, filename_completer
);
2096 add_com_alias ("!", "shell", class_support
, 0);
2098 c
= add_com ("edit", class_files
, edit_command
, _("\
2099 Edit specified file or function.\n\
2100 With no argument, edits file containing most recent line listed.\n\
2101 Editing targets can be specified in these ways:\n\
2102 FILE:LINENUM, to edit at that line in that file,\n\
2103 FUNCTION, to edit at the beginning of that function,\n\
2104 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2105 *ADDRESS, to edit at the line containing that address.\n\
2106 Uses EDITOR environment variable contents as editor (or ex as default)."));
2108 c
->completer
= location_completer
;
2110 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2111 Send the output of a gdb command to a shell command.\n\
2112 Usage: | [COMMAND] | SHELL_COMMAND\n\
2113 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2114 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2115 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2117 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2119 The -d option indicates to use the string DELIM to separate COMMAND\n\
2120 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2121 case COMMAND contains a | character.\n\
2123 With no COMMAND, repeat the last executed command\n\
2124 and send its output to SHELL_COMMAND."));
2125 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2126 add_com_alias ("|", "pipe", class_support
, 0);
2128 add_com ("list", class_files
, list_command
, _("\
2129 List specified function or line.\n\
2130 With no argument, lists ten more lines after or around previous listing.\n\
2131 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2132 One argument specifies a line, and ten lines are listed around that line.\n\
2133 Two arguments with comma between specify starting and ending lines to list.\n\
2134 Lines can be specified in these ways:\n\
2135 LINENUM, to list around that line in current file,\n\
2136 FILE:LINENUM, to list around that line in that file,\n\
2137 FUNCTION, to list around beginning of that function,\n\
2138 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2139 *ADDRESS, to list around the line containing that address.\n\
2140 With two args, if one is empty, it stands for ten lines away from\n\
2143 By default, when a single location is given, display ten lines.\n\
2144 This can be changed using \"set listsize\", and the current value\n\
2145 can be shown using \"show listsize\"."));
2147 add_com_alias ("l", "list", class_files
, 1);
2150 add_com_alias ("file", "list", class_files
, 1);
2152 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2153 Disassemble a specified section of memory.\n\
2154 Default is the function surrounding the pc of the selected frame.\n\
2156 With a /m modifier, source lines are included (if available).\n\
2157 This view is \"source centric\": the output is in source line order,\n\
2158 regardless of any optimization that is present. Only the main source file\n\
2159 is displayed, not those of, e.g., any inlined functions.\n\
2160 This modifier hasn't proved useful in practice and is deprecated\n\
2163 With a /s modifier, source lines are included (if available).\n\
2164 This differs from /m in two important respects:\n\
2165 - the output is still in pc address order, and\n\
2166 - file names and contents for all relevant source files are displayed.\n\
2168 With a /r modifier, raw instructions in hex are included.\n\
2170 With a single argument, the function surrounding that address is dumped.\n\
2171 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2172 in the form of \"start,end\", or \"start,+length\".\n\
2174 Note that the address is interpreted as an expression, not as a location\n\
2175 like in the \"break\" command.\n\
2176 So, for example, if you want to disassemble function bar in file foo.c\n\
2177 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2178 set_cmd_completer (c
, location_completer
);
2180 c
= add_com ("make", class_support
, make_command
, _("\
2181 Run the ``make'' program using the rest of the line as arguments."));
2182 set_cmd_completer (c
, filename_completer
);
2183 add_cmd ("user", no_class
, show_user
, _("\
2184 Show definitions of non-python/scheme user defined commands.\n\
2185 Argument is the name of the user defined command.\n\
2186 With no argument, show definitions of all user defined commands."), &showlist
);
2187 add_com ("apropos", class_support
, apropos_command
, _("\
2188 Search for commands matching a REGEXP.\n\
2189 Usage: apropos [-v] REGEXP\n\
2190 Flag -v indicates to produce a verbose output, showing full documentation\n\
2191 of the matching commands."));
2193 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2194 &max_user_call_depth
, _("\
2195 Set the max call depth for non-python/scheme user-defined commands."), _("\
2196 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2198 show_max_user_call_depth
,
2199 &setlist
, &showlist
);
2201 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2202 Set tracing of GDB CLI commands."), _("\
2203 Show state of GDB CLI command tracing."), _("\
2204 When 'on', each command is displayed as it is executed."),
2207 &setlist
, &showlist
);
2209 c
= add_com ("alias", class_support
, alias_command
, _("\
2210 Define a new command that is an alias of an existing command.\n\
2211 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2212 ALIAS is the name of the alias command to create.\n\
2213 COMMAND is the command being aliased to.\n\
2214 If \"-a\" is specified, the command is an abbreviation,\n\
2215 and will not appear in help command list output.\n\
2218 Make \"spe\" an alias of \"set print elements\":\n\
2219 alias spe = set print elements\n\
2220 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2221 alias -a set print elms = set print elements"));
2223 const char *source_help_text
= xstrprintf (_("\
2224 Read commands from a file named FILE.\n\
2226 Usage: source [-s] [-v] FILE\n\
2227 -s: search for the script in the source search path,\n\
2228 even if FILE contains directories.\n\
2229 -v: each command in FILE is echoed as it is executed.\n\
2231 Note that the file \"%s\" is read automatically in this way\n\
2232 when GDB is started."), GDBINIT
);
2233 c
= add_cmd ("source", class_support
, source_command
,
2234 source_help_text
, &cmdlist
);
2235 set_cmd_completer (c
, filename_completer
);