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