3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "exceptions.h"
23 #include "arch-utils.h"
24 #include "dyn-string.h"
25 #include "readline/readline.h"
26 #include "readline/tilde.h"
27 #include "completer.h"
28 #include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
29 #include "gdb_wait.h" /* For shell escape implementation. */
30 #include "gdb_regex.h" /* Used by apropos_command. */
31 #include "gdb_string.h"
32 #include "gdb_vfork.h"
34 #include "expression.h"
38 #include "filenames.h" /* For DOSish file names. */
42 #include "tracepoint.h"
47 #include "cli/cli-decode.h"
48 #include "cli/cli-script.h"
49 #include "cli/cli-setshow.h"
50 #include "cli/cli-cmds.h"
52 #include "python/python.h"
55 #include "tui/tui.h" /* For tui_active et.al. */
60 /* Prototypes for local command functions */
62 static void complete_command (char *, int);
64 static void echo_command (char *, int);
66 static void pwd_command (char *, int);
68 static void show_version (char *, int);
70 static void help_command (char *, int);
72 static void show_command (char *, int);
74 static void info_command (char *, int);
76 static void show_debug (char *, int);
78 static void set_debug (char *, int);
80 static void show_user (char *, int);
82 static void make_command (char *, int);
84 static void shell_escape (char *, int);
86 static void edit_command (char *, int);
88 static void list_command (char *, int);
90 void apropos_command (char *, int);
92 /* Prototypes for local utility functions */
94 static void ambiguous_line_spec (struct symtabs_and_lines *);
96 static void filter_sals (struct symtabs_and_lines *);
99 /* Limit the call depth of user-defined commands */
100 int max_user_call_depth;
102 /* Define all cmd_list_elements. */
104 /* Chain containing all defined commands. */
106 struct cmd_list_element *cmdlist;
108 /* Chain containing all defined info subcommands. */
110 struct cmd_list_element *infolist;
112 /* Chain containing all defined enable subcommands. */
114 struct cmd_list_element *enablelist;
116 /* Chain containing all defined disable subcommands. */
118 struct cmd_list_element *disablelist;
120 /* Chain containing all defined toggle subcommands. */
122 struct cmd_list_element *togglelist;
124 /* Chain containing all defined stop subcommands. */
126 struct cmd_list_element *stoplist;
128 /* Chain containing all defined delete subcommands. */
130 struct cmd_list_element *deletelist;
132 /* Chain containing all defined detach subcommands. */
134 struct cmd_list_element *detachlist;
136 /* Chain containing all defined kill subcommands. */
138 struct cmd_list_element *killlist;
140 /* Chain containing all defined "enable breakpoint" subcommands. */
142 struct cmd_list_element *enablebreaklist;
144 /* Chain containing all defined set subcommands */
146 struct cmd_list_element *setlist;
148 /* Chain containing all defined unset subcommands */
150 struct cmd_list_element *unsetlist;
152 /* Chain containing all defined show subcommands. */
154 struct cmd_list_element *showlist;
156 /* Chain containing all defined \"set history\". */
158 struct cmd_list_element *sethistlist;
160 /* Chain containing all defined \"show history\". */
162 struct cmd_list_element *showhistlist;
164 /* Chain containing all defined \"unset history\". */
166 struct cmd_list_element *unsethistlist;
168 /* Chain containing all defined maintenance subcommands. */
170 struct cmd_list_element *maintenancelist;
172 /* Chain containing all defined "maintenance info" subcommands. */
174 struct cmd_list_element *maintenanceinfolist;
176 /* Chain containing all defined "maintenance print" subcommands. */
178 struct cmd_list_element *maintenanceprintlist;
180 struct cmd_list_element *setprintlist;
182 struct cmd_list_element *showprintlist;
184 struct cmd_list_element *setdebuglist;
186 struct cmd_list_element *showdebuglist;
188 struct cmd_list_element *setchecklist;
190 struct cmd_list_element *showchecklist;
192 struct cmd_list_element *skiplist;
194 /* Command tracing state. */
196 int source_verbose = 0;
197 int trace_commands = 0;
199 /* 'script-extension' option support. */
201 static const char script_ext_off[] = "off";
202 static const char script_ext_soft[] = "soft";
203 static const char script_ext_strict[] = "strict";
205 static const char *script_ext_enums[] = {
212 static const char *script_ext_mode = script_ext_soft;
214 /* Utility used everywhere when at least one argument is needed and
218 error_no_arg (char *why)
220 error (_("Argument required (%s)."), why);
223 /* The "info" command is defined as a prefix, with allow_unknown = 0.
224 Therefore, its own definition is called only for "info" with no
228 info_command (char *arg, int from_tty)
230 printf_unfiltered (_("\"info\" must be followed by "
231 "the name of an info command.\n"));
232 help_list (infolist, "info ", -1, gdb_stdout);
235 /* The "show" command with no arguments shows all the settings. */
238 show_command (char *arg, int from_tty)
240 cmd_show_list (showlist, from_tty, "");
243 /* Provide documentation on command or list given by COMMAND. FROM_TTY
247 help_command (char *command, int from_tty)
249 help_cmd (command, gdb_stdout);
252 /* The "complete" command is used by Emacs to implement completion. */
255 complete_command (char *arg, int from_tty)
258 char **completions, *point, *arg_prefix;
264 argpoint = strlen (arg);
266 /* complete_line assumes that its first argument is somewhere
267 within, and except for filenames at the beginning of, the word to
268 be completed. The following crude imitation of readline's
269 word-breaking tries to accomodate this. */
270 point = arg + argpoint;
273 if (strchr (rl_completer_word_break_characters, point[-1]) != 0)
278 arg_prefix = alloca (point - arg + 1);
279 memcpy (arg_prefix, arg, point - arg);
280 arg_prefix[point - arg] = 0;
282 completions = complete_line (point, arg, argpoint);
288 for (size = 0; completions[size]; ++size)
290 qsort (completions, size, sizeof (char *), compare_strings);
292 /* We do extra processing here since we only want to print each
299 printf_unfiltered ("%s%s\n", arg_prefix, completions[item]);
300 next_item = item + 1;
301 while (next_item < size
302 && ! strcmp (completions[item], completions[next_item]))
304 xfree (completions[next_item]);
308 xfree (completions[item]);
317 is_complete_command (struct cmd_list_element *c)
319 return cmd_cfunc_eq (c, complete_command);
323 show_version (char *args, int from_tty)
326 print_gdb_version (gdb_stdout);
327 printf_filtered ("\n");
331 /* Handle the quit command. */
334 quit_command (char *args, int from_tty)
336 if (!quit_confirm ())
337 error (_("Not confirmed."));
339 disconnect_tracing (from_tty);
341 quit_force (args, from_tty);
345 pwd_command (char *args, int from_tty)
348 error (_("The \"pwd\" command does not take an argument: %s"), args);
349 if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
350 error (_("Error finding name of working directory: %s"),
351 safe_strerror (errno));
353 if (strcmp (gdb_dirbuf, current_directory) != 0)
354 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
355 current_directory, gdb_dirbuf);
357 printf_unfiltered (_("Working directory %s.\n"), current_directory);
361 cd_command (char *dir, int from_tty)
364 /* Found something other than leading repetitions of "/..". */
368 /* If the new directory is absolute, repeat is a no-op; if relative,
369 repeat might be useful but is more likely to be a mistake. */
373 error_no_arg (_("new working directory"));
375 dir = tilde_expand (dir);
376 make_cleanup (xfree, dir);
379 perror_with_name (dir);
381 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
382 /* There's too much mess with DOSish names like "d:", "d:.",
383 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
384 simply get the canonicalized name of the current directory. */
385 dir = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
389 if (IS_DIR_SEPARATOR (dir[len - 1]))
391 /* Remove the trailing slash unless this is a root directory
392 (including a drive letter on non-Unix systems). */
393 if (!(len == 1) /* "/" */
394 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
395 && !(len == 3 && dir[1] == ':') /* "d:/" */
401 dir = savestring (dir, len);
402 if (IS_ABSOLUTE_PATH (dir))
403 current_directory = dir;
406 if (IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1]))
407 current_directory = concat (current_directory, dir, (char *)NULL);
409 current_directory = concat (current_directory, SLASH_STRING,
414 /* Now simplify any occurrences of `.' and `..' in the pathname. */
417 for (p = current_directory; *p;)
419 if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.'
420 && (p[2] == 0 || IS_DIR_SEPARATOR (p[2])))
422 else if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' && p[2] == '.'
423 && (p[3] == 0 || IS_DIR_SEPARATOR (p[3])))
427 /* Search backwards for the directory just before the "/.."
428 and obliterate it and the "/..". */
431 while (q != current_directory && !IS_DIR_SEPARATOR (q[-1]))
434 if (q == current_directory)
435 /* current_directory is
436 a relative pathname ("can't happen"--leave it alone). */
440 strcpy (q - 1, p + 3);
445 /* We are dealing with leading repetitions of "/..", for
446 example "/../..", which is the Mach super-root. */
456 forget_cached_source_info ();
459 pwd_command ((char *) 0, 1);
462 /* Show the current value of the 'script-extension' option. */
465 show_script_ext_mode (struct ui_file *file, int from_tty,
466 struct cmd_list_element *c, const char *value)
468 fprintf_filtered (file,
469 _("Script filename extension recognition is \"%s\".\n"),
473 /* Try to open SCRIPT_FILE.
474 If successful, the full path name is stored in *FULL_PATHP,
475 the stream is stored in *STREAMP, and return 1.
476 The caller is responsible for freeing *FULL_PATHP.
477 If not successful, return 0; errno is set for the last file
480 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
481 search for it in the source search path.
483 NOTE: This calls openp which uses xfullpath to compute the full path
484 instead of gdb_realpath. Symbolic links are not resolved. */
487 find_and_open_script (const char *script_file, int search_path,
488 FILE **streamp, char **full_pathp)
492 struct cleanup *old_cleanups;
493 int search_flags = OPF_TRY_CWD_FIRST;
495 file = tilde_expand (script_file);
496 old_cleanups = make_cleanup (xfree, file);
499 search_flags |= OPF_SEARCH_IN_PATH;
501 /* Search for and open 'file' on the search path used for source
502 files. Put the full location in *FULL_PATHP. */
503 fd = openp (source_path, search_flags,
504 file, O_RDONLY, full_pathp);
508 int save_errno = errno;
509 do_cleanups (old_cleanups);
514 do_cleanups (old_cleanups);
516 *streamp = fdopen (fd, FOPEN_RT);
520 /* Load script FILE, which has already been opened as STREAM.
521 STREAM is closed before we return. */
524 source_script_from_stream (FILE *stream, const char *file)
526 if (script_ext_mode != script_ext_off
527 && strlen (file) > 3 && !strcmp (&file[strlen (file) - 3], ".py"))
529 volatile struct gdb_exception e;
531 TRY_CATCH (e, RETURN_MASK_ERROR)
533 /* The python support reopens the file using python functions,
534 so there's no point in passing STREAM here. */
535 source_python_script (file);
539 /* Should we fallback to ye olde GDB script mode? */
540 if (script_ext_mode == script_ext_soft
541 && e.reason == RETURN_ERROR && e.error == UNSUPPORTED_ERROR)
543 fseek (stream, 0, SEEK_SET);
544 script_from_file (stream, (char*) file);
548 /* Nope, just punt. */
557 script_from_file (stream, file);
560 /* Worker to perform the "source" command.
562 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
563 search for it in the source search path. */
566 source_script_with_search (const char *file, int from_tty, int search_path)
570 struct cleanup *old_cleanups;
572 if (file == NULL || *file == 0)
573 error (_("source command requires file name of file to source."));
575 if (!find_and_open_script (file, search_path, &stream, &full_path))
577 /* The script wasn't found, or was otherwise inaccessible.
578 If the source command was invoked interactively, throw an
579 error. Otherwise (e.g. if it was invoked by a script),
580 silently ignore the error. */
582 perror_with_name (file);
587 old_cleanups = make_cleanup (xfree, full_path);
588 /* The python support reopens the file, so we need to pass full_path here
589 in case the file was found on the search path. It's useful to do this
590 anyway so that error messages show the actual file used. But only do
591 this if we (may have) used search_path, as printing the full path in
592 errors for the non-search case can be more noise than signal. */
593 source_script_from_stream (stream, search_path ? full_path : file);
594 do_cleanups (old_cleanups);
597 /* Wrapper around source_script_with_search to export it to main.c
598 for use in loading .gdbinit scripts. */
601 source_script (char *file, int from_tty)
603 source_script_with_search (file, from_tty, 0);
606 /* Return the source_verbose global variable to its previous state
607 on exit from the source command, by whatever means. */
609 source_verbose_cleanup (void *old_value)
611 source_verbose = *(int *)old_value;
616 source_command (char *args, int from_tty)
618 struct cleanup *old_cleanups;
620 int *old_source_verbose = xmalloc (sizeof(int));
623 *old_source_verbose = source_verbose;
624 old_cleanups = make_cleanup (source_verbose_cleanup,
627 /* -v causes the source command to run in verbose mode.
628 -s causes the file to be searched in the source search path,
629 even if the file name contains a '/'.
630 We still have to be able to handle filenames with spaces in a
631 backward compatible way, so buildargv is not appropriate. */
635 while (args[0] != '\0')
637 /* Make sure leading white space does not break the
639 while (isspace(args[0]))
645 if (args[1] == 'v' && isspace (args[2]))
649 /* Skip passed -v. */
652 else if (args[1] == 's' && isspace (args[2]))
656 /* Skip passed -s. */
663 while (isspace (args[0]))
668 source_script_with_search (file, from_tty, search_path);
670 do_cleanups (old_cleanups);
675 echo_command (char *text, int from_tty)
681 while ((c = *p++) != '\0')
685 /* \ at end of argument is used after spaces
686 so they won't be lost. */
690 c = parse_escape (get_current_arch (), &p);
692 printf_filtered ("%c", c);
695 printf_filtered ("%c", c);
698 /* Force this output to appear now. */
700 gdb_flush (gdb_stdout);
704 shell_escape (char *arg, int from_tty)
706 #if defined(CANT_FORK) || \
707 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
708 /* If ARG is NULL, they want an inferior shell, but `system' just
709 reports if the shell is available when passed a NULL arg. */
710 int rc = system (arg ? arg : "");
713 arg = "inferior shell";
717 fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg,
718 safe_strerror (errno));
719 gdb_flush (gdb_stderr);
723 fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc);
724 gdb_flush (gdb_stderr);
727 /* Make sure to return to the directory GDB thinks it is, in case
728 the shell command we just ran changed it. */
729 chdir (current_directory);
731 #else /* Can fork. */
734 if ((pid = vfork ()) == 0)
736 const char *p, *user_shell;
738 if ((user_shell = (char *) getenv ("SHELL")) == NULL)
739 user_shell = "/bin/sh";
741 /* Get the name of the shell for arg0. */
742 p = lbasename (user_shell);
745 execl (user_shell, p, (char *) 0);
747 execl (user_shell, p, "-c", arg, (char *) 0);
749 fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
750 safe_strerror (errno));
751 gdb_flush (gdb_stderr);
756 waitpid (pid, &status, 0);
758 error (_("Fork failed"));
759 #endif /* Can fork. */
763 edit_command (char *arg, int from_tty)
765 struct symtabs_and_lines sals;
766 struct symtab_and_line sal;
772 /* Pull in the current default source line if necessary. */
775 set_default_source_symtab_and_line ();
776 sal = get_current_source_symtab_and_line ();
779 /* Bare "edit" edits file with present line. */
784 error (_("No default source file yet."));
785 sal.line += get_lines_to_list () / 2;
789 /* Now should only be one argument -- decode it in SAL. */
792 sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
802 ambiguous_line_spec (&sals);
811 error (_("Junk at end of line specification."));
813 /* If line was specified by address, first print exactly which
814 line, and which file. In this case, sal.symtab == 0 means
815 address is outside of all known source files, not that user
816 failed to give a filename. */
819 struct gdbarch *gdbarch;
822 /* FIXME-32x64--assumes sal.pc fits in long. */
823 error (_("No source file for address %s."),
824 hex_string ((unsigned long) sal.pc));
826 gdbarch = get_objfile_arch (sal.symtab->objfile);
827 sym = find_pc_function (sal.pc);
829 printf_filtered ("%s is in %s (%s:%d).\n",
830 paddress (gdbarch, sal.pc),
831 SYMBOL_PRINT_NAME (sym),
832 sal.symtab->filename, sal.line);
834 printf_filtered ("%s is at %s:%d.\n",
835 paddress (gdbarch, sal.pc),
836 sal.symtab->filename, sal.line);
839 /* If what was given does not imply a symtab, it must be an
840 undebuggable symbol which means no source code. */
843 error (_("No line number known for %s."), arg);
846 if ((editor = (char *) getenv ("EDITOR")) == NULL)
849 /* If we don't already know the full absolute file name of the
850 source file, find it now. */
851 if (!sal.symtab->fullname)
853 fn = symtab_to_fullname (sal.symtab);
858 fn = sal.symtab->fullname;
860 /* Quote the file name, in case it has whitespace or other special
862 p = xstrprintf ("%s +%d \"%s\"", editor, sal.line, fn);
863 shell_escape (p, from_tty);
868 list_command (char *arg, int from_tty)
870 struct symtabs_and_lines sals, sals_end;
871 struct symtab_and_line sal = { 0 };
872 struct symtab_and_line sal_end = { 0 };
873 struct symtab_and_line cursal = { 0 };
882 /* Pull in the current default source line if necessary. */
883 if (arg == 0 || arg[0] == '+' || arg[0] == '-')
885 set_default_source_symtab_and_line ();
886 cursal = get_current_source_symtab_and_line ();
889 /* "l" or "l +" lists next ten lines. */
891 if (arg == 0 || strcmp (arg, "+") == 0)
893 print_source_lines (cursal.symtab, cursal.line,
894 cursal.line + get_lines_to_list (), 0);
898 /* "l -" lists previous ten lines, the ones before the ten just
900 if (strcmp (arg, "-") == 0)
902 print_source_lines (cursal.symtab,
903 max (get_first_line_listed ()
904 - get_lines_to_list (), 1),
905 get_first_line_listed (), 0);
909 /* Now if there is only one argument, decode it in SAL
911 If there are two arguments, decode them in SAL and SAL_END
912 and clear NO_END; however, if one of the arguments is blank,
913 set DUMMY_BEG or DUMMY_END to record that fact. */
915 if (!have_full_symbols () && !have_partial_symbols ())
916 error (_("No symbol table is loaded. Use the \"file\" command."));
923 sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
930 ambiguous_line_spec (&sals);
939 /* Record whether the BEG arg is all digits. */
941 for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
942 linenum_beg = (p == arg1);
944 while (*arg1 == ' ' || *arg1 == '\t')
950 while (*arg1 == ' ' || *arg1 == '\t')
957 sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
959 sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE,
960 sal.symtab, sal.line);
962 if (sals_end.nelts == 0)
964 if (sals_end.nelts > 1)
966 ambiguous_line_spec (&sals_end);
967 xfree (sals_end.sals);
970 sal_end = sals_end.sals[0];
971 xfree (sals_end.sals);
976 error (_("Junk at end of line specification."));
978 if (!no_end && !dummy_beg && !dummy_end
979 && sal.symtab != sal_end.symtab)
980 error (_("Specified start and end are in different files."));
981 if (dummy_beg && dummy_end)
982 error (_("Two empty args do not say what lines to list."));
984 /* If line was specified by address,
985 first print exactly which line, and which file.
987 In this case, sal.symtab == 0 means address is outside of all
988 known source files, not that user failed to give a filename. */
991 struct gdbarch *gdbarch;
994 /* FIXME-32x64--assumes sal.pc fits in long. */
995 error (_("No source file for address %s."),
996 hex_string ((unsigned long) sal.pc));
998 gdbarch = get_objfile_arch (sal.symtab->objfile);
999 sym = find_pc_function (sal.pc);
1001 printf_filtered ("%s is in %s (%s:%d).\n",
1002 paddress (gdbarch, sal.pc),
1003 SYMBOL_PRINT_NAME (sym),
1004 sal.symtab->filename, sal.line);
1006 printf_filtered ("%s is at %s:%d.\n",
1007 paddress (gdbarch, sal.pc),
1008 sal.symtab->filename, sal.line);
1011 /* If line was not specified by just a line number, and it does not
1012 imply a symtab, it must be an undebuggable symbol which means no
1015 if (!linenum_beg && sal.symtab == 0)
1016 error (_("No line number known for %s."), arg);
1018 /* If this command is repeated with RET,
1019 turn it into the no-arg variant. */
1024 if (dummy_beg && sal_end.symtab == 0)
1025 error (_("No default source file yet. Do \"help list\"."));
1027 print_source_lines (sal_end.symtab,
1028 max (sal_end.line - (get_lines_to_list () - 1), 1),
1029 sal_end.line + 1, 0);
1030 else if (sal.symtab == 0)
1031 error (_("No default source file yet. Do \"help list\"."));
1034 int first_line = sal.line - get_lines_to_list () / 2;
1036 if (first_line < 1) first_line = 1;
1038 print_source_lines (sal.symtab,
1040 first_line + get_lines_to_list (),
1044 print_source_lines (sal.symtab, sal.line,
1046 ? sal.line + get_lines_to_list ()
1047 : sal_end.line + 1),
1051 /* Subroutine of disassemble_command to simplify it.
1052 Perform the disassembly.
1053 NAME is the name of the function if known, or NULL.
1054 [LOW,HIGH) are the range of addresses to disassemble.
1055 MIXED is non-zero to print source with the assembler. */
1058 print_disassembly (struct gdbarch *gdbarch, const char *name,
1059 CORE_ADDR low, CORE_ADDR high, int flags)
1062 if (!tui_is_window_visible (DISASSEM_WIN))
1065 printf_filtered ("Dump of assembler code ");
1067 printf_filtered ("for function %s:\n", name);
1069 printf_filtered ("from %s to %s:\n",
1070 paddress (gdbarch, low), paddress (gdbarch, high));
1072 /* Dump the specified range. */
1073 gdb_disassembly (gdbarch, current_uiout, 0, flags, -1, low, high);
1075 printf_filtered ("End of assembler dump.\n");
1076 gdb_flush (gdb_stdout);
1081 tui_show_assembly (gdbarch, low);
1086 /* Subroutine of disassemble_command to simplify it.
1087 Print a disassembly of the current function according to FLAGS. */
1090 disassemble_current_function (int flags)
1092 struct frame_info *frame;
1093 struct gdbarch *gdbarch;
1094 CORE_ADDR low, high, pc;
1097 frame = get_selected_frame (_("No frame selected."));
1098 gdbarch = get_frame_arch (frame);
1099 pc = get_frame_pc (frame);
1100 if (find_pc_partial_function (pc, &name, &low, &high) == 0)
1101 error (_("No function contains program counter for selected frame."));
1103 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1106 /* FIXME: cagney/2004-02-07: This should be an observer. */
1107 low = tui_get_low_disassembly_address (gdbarch, low, pc);
1109 low += gdbarch_deprecated_function_start_offset (gdbarch);
1111 print_disassembly (gdbarch, name, low, high, flags);
1114 /* Dump a specified section of assembly code.
1118 - dump the assembly code for the function of the current pc
1119 disassemble [/mr] addr
1120 - dump the assembly code for the function at ADDR
1121 disassemble [/mr] low,high
1122 disassemble [/mr] low,+length
1123 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1125 A /m modifier will include source code with the assembly.
1126 A /r modifier will include raw instructions in hex with the assembly. */
1129 disassemble_command (char *arg, int from_tty)
1131 struct gdbarch *gdbarch = get_current_arch ();
1132 CORE_ADDR low, high;
1140 if (arg && *arg == '/')
1145 error (_("Missing modifier."));
1147 while (*arg && ! isspace (*arg))
1152 flags |= DISASSEMBLY_SOURCE;
1155 flags |= DISASSEMBLY_RAW_INSN;
1158 error (_("Invalid disassembly modifier."));
1162 while (isspace (*arg))
1166 if (! arg || ! *arg)
1168 flags |= DISASSEMBLY_OMIT_FNAME;
1169 disassemble_current_function (flags);
1173 pc = value_as_address (parse_to_comma_and_eval (&arg));
1179 if (find_pc_partial_function (pc, &name, &low, &high) == 0)
1180 error (_("No function contains specified address."));
1182 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1185 /* FIXME: cagney/2004-02-07: This should be an observer. */
1186 low = tui_get_low_disassembly_address (gdbarch, low, pc);
1188 low += gdbarch_deprecated_function_start_offset (gdbarch);
1189 flags |= DISASSEMBLY_OMIT_FNAME;
1193 /* Two arguments. */
1196 while (isspace (*arg))
1203 high = parse_and_eval_address (arg);
1208 print_disassembly (gdbarch, name, low, high, flags);
1212 make_command (char *arg, int from_tty)
1220 p = xmalloc (sizeof ("make ") + strlen (arg));
1221 strcpy (p, "make ");
1222 strcpy (p + sizeof ("make ") - 1, arg);
1225 shell_escape (p, from_tty);
1229 show_user (char *args, int from_tty)
1231 struct cmd_list_element *c;
1232 extern struct cmd_list_element *cmdlist;
1236 char *comname = args;
1238 c = lookup_cmd (&comname, cmdlist, "", 0, 1);
1239 if (c->class != class_user)
1240 error (_("Not a user command."));
1241 show_user_1 (c, "", args, gdb_stdout);
1245 for (c = cmdlist; c; c = c->next)
1247 if (c->class == class_user || c->prefixlist != NULL)
1248 show_user_1 (c, "", c->name, gdb_stdout);
1253 /* Search through names of commands and documentations for a certain
1254 regular expression. */
1257 apropos_command (char *searchstr, int from_tty)
1262 if (searchstr == NULL)
1263 error (_("REGEXP string is empty"));
1265 code = regcomp (&pattern, searchstr, REG_ICASE);
1268 struct cleanup *cleanups;
1270 cleanups = make_regfree_cleanup (&pattern);
1271 apropos_cmd (gdb_stdout, cmdlist, &pattern, "");
1272 do_cleanups (cleanups);
1276 char *err = get_regcomp_error (code, &pattern);
1278 make_cleanup (xfree, err);
1279 error (_("Error in regular expression: %s"), err);
1283 /* Subroutine of alias_command to simplify it.
1284 Return the first N elements of ARGV flattened back to a string
1285 with a space separating each element.
1286 ARGV may not be NULL.
1287 This does not take care of quoting elements in case they contain spaces
1291 argv_to_dyn_string (char **argv, int n)
1294 dyn_string_t result = dyn_string_new (10);
1296 gdb_assert (argv != NULL);
1297 gdb_assert (n >= 0 && n <= countargv (argv));
1299 for (i = 0; i < n; ++i)
1302 dyn_string_append_char (result, ' ');
1303 dyn_string_append_cstr (result, argv[i]);
1309 /* Subroutine of alias_command to simplify it.
1310 Return TRUE if COMMAND exists, unambiguously. Otherwise FALSE. */
1313 valid_command_p (char *command)
1315 struct cmd_list_element *c;
1317 c = lookup_cmd_1 (& command, cmdlist, NULL, 1);
1319 if (c == NULL || c == (struct cmd_list_element *) -1)
1322 /* This is the slightly tricky part.
1323 lookup_cmd_1 will return a pointer to the last part of COMMAND
1324 to match, leaving COMMAND pointing at the remainder. */
1325 while (*command == ' ' || *command == '\t')
1327 return *command == '\0';
1330 /* Make an alias of an existing command. */
1333 alias_command (char *args, int from_tty)
1335 int i, alias_argc, command_argc;
1336 int abbrev_flag = 0;
1337 char *args2, *equals, *alias, *command;
1338 char **alias_argv, **command_argv;
1339 dyn_string_t alias_dyn_string, command_dyn_string;
1340 struct cmd_list_element *c;
1341 static const char usage[] = N_("Usage: alias [-a] [--] ALIAS = COMMAND");
1343 if (args == NULL || strchr (args, '=') == NULL)
1346 args2 = xstrdup (args);
1347 make_cleanup (xfree, args2);
1348 equals = strchr (args2, '=');
1350 alias_argv = gdb_buildargv (args2);
1351 make_cleanup_freeargv (alias_argv);
1352 command_argv = gdb_buildargv (equals + 1);
1353 make_cleanup_freeargv (command_argv);
1355 for (i = 0; alias_argv[i] != NULL; )
1357 if (strcmp (alias_argv[i], "-a") == 0)
1362 else if (strcmp (alias_argv[i], "--") == 0)
1371 if (alias_argv[0] == NULL || command_argv[0] == NULL
1372 || *alias_argv[0] == '\0' || *command_argv[0] == '\0')
1375 for (i = 0; alias_argv[i] != NULL; ++i)
1377 if (! valid_user_defined_cmd_name_p (alias_argv[i]))
1380 error (_("Invalid command name: %s"), alias_argv[i]);
1382 error (_("Invalid command element name: %s"), alias_argv[i]);
1386 alias_argc = countargv (alias_argv);
1387 command_argc = countargv (command_argv);
1389 /* COMMAND must exist.
1390 Reconstruct the command to remove any extraneous spaces,
1391 for better error messages. */
1392 command_dyn_string = argv_to_dyn_string (command_argv, command_argc);
1393 make_cleanup_dyn_string_delete (command_dyn_string);
1394 command = dyn_string_buf (command_dyn_string);
1395 if (! valid_command_p (command))
1396 error (_("Invalid command to alias to: %s"), command);
1398 /* ALIAS must not exist. */
1399 alias_dyn_string = argv_to_dyn_string (alias_argv, alias_argc);
1400 make_cleanup_dyn_string_delete (alias_dyn_string);
1401 alias = dyn_string_buf (alias_dyn_string);
1402 if (valid_command_p (alias))
1403 error (_("Alias already exists: %s"), alias);
1405 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1406 Example: alias spe = set print elements
1408 Otherwise ALIAS and COMMAND must have the same number of words,
1409 and every word except the last must match; and the last word of
1410 ALIAS is made an alias of the last word of COMMAND.
1411 Example: alias set print elms = set pr elem
1412 Note that unambiguous abbreviations are allowed. */
1414 if (alias_argc == 1)
1416 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1417 add_com_alias (xstrdup (alias_argv[0]), command, class_alias,
1423 dyn_string_t alias_prefix_dyn_string, command_prefix_dyn_string;
1424 char *alias_prefix, *command_prefix;
1425 struct cmd_list_element *c_alias, *c_command;
1427 if (alias_argc != command_argc)
1428 error (_("Mismatched command length between ALIAS and COMMAND."));
1430 /* Create copies of ALIAS and COMMAND without the last word,
1431 and use that to verify the leading elements match. */
1432 alias_prefix_dyn_string =
1433 argv_to_dyn_string (alias_argv, alias_argc - 1);
1434 make_cleanup_dyn_string_delete (alias_prefix_dyn_string);
1435 command_prefix_dyn_string =
1436 argv_to_dyn_string (alias_argv, command_argc - 1);
1437 make_cleanup_dyn_string_delete (command_prefix_dyn_string);
1438 alias_prefix = dyn_string_buf (alias_prefix_dyn_string);
1439 command_prefix = dyn_string_buf (command_prefix_dyn_string);
1441 c_command = lookup_cmd_1 (& command_prefix, cmdlist, NULL, 1);
1442 /* We've already tried to look up COMMAND. */
1443 gdb_assert (c_command != NULL
1444 && c_command != (struct cmd_list_element *) -1);
1445 gdb_assert (c_command->prefixlist != NULL);
1446 c_alias = lookup_cmd_1 (& alias_prefix, cmdlist, NULL, 1);
1447 if (c_alias != c_command)
1448 error (_("ALIAS and COMMAND prefixes do not match."));
1450 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1451 add_alias_cmd (xstrdup (alias_argv[alias_argc - 1]),
1452 command_argv[command_argc - 1],
1453 class_alias, abbrev_flag, c_command->prefixlist);
1457 /* Print a list of files and line numbers which a user may choose from
1458 in order to list a function which was specified ambiguously (as
1459 with `list classname::overloadedfuncname', for example). The
1460 vector in SALS provides the filenames and line numbers. */
1463 ambiguous_line_spec (struct symtabs_and_lines *sals)
1467 for (i = 0; i < sals->nelts; ++i)
1468 printf_filtered (_("file: \"%s\", line number: %d\n"),
1469 sals->sals[i].symtab->filename, sals->sals[i].line);
1472 /* Sort function for filter_sals. */
1475 compare_symtabs (const void *a, const void *b)
1477 const struct symtab_and_line *sala = a;
1478 const struct symtab_and_line *salb = b;
1481 if (!sala->symtab->dirname)
1483 if (salb->symtab->dirname)
1486 else if (!salb->symtab->dirname)
1488 if (sala->symtab->dirname)
1493 r = filename_cmp (sala->symtab->dirname, salb->symtab->dirname);
1498 r = filename_cmp (sala->symtab->filename, salb->symtab->filename);
1502 if (sala->line < salb->line)
1504 return sala->line == salb->line ? 0 : 1;
1507 /* Remove any SALs that do not match the current program space, or
1508 which appear to be "file:line" duplicates. */
1511 filter_sals (struct symtabs_and_lines *sals)
1516 for (i = 0; i < sals->nelts; ++i)
1518 if (sals->sals[i].pspace == current_program_space
1519 && sals->sals[i].symtab != NULL)
1521 sals->sals[out] = sals->sals[i];
1527 qsort (sals->sals, sals->nelts, sizeof (struct symtab_and_line),
1532 for (i = 1; i < sals->nelts; ++i)
1534 if (compare_symtabs (&sals->sals[prev], &sals->sals[i]))
1536 /* Symtabs differ. */
1537 sals->sals[out] = sals->sals[i];
1544 if (sals->nelts == 0)
1552 set_debug (char *arg, int from_tty)
1554 printf_unfiltered (_("\"set debug\" must be followed by "
1555 "the name of a debug subcommand.\n"));
1556 help_list (setdebuglist, "set debug ", -1, gdb_stdout);
1560 show_debug (char *args, int from_tty)
1562 cmd_show_list (showdebuglist, from_tty, "");
1566 init_cmd_lists (void)
1568 max_user_call_depth = 1024;
1578 enablebreaklist = NULL;
1583 showhistlist = NULL;
1584 unsethistlist = NULL;
1585 maintenancelist = NULL;
1586 maintenanceinfolist = NULL;
1587 maintenanceprintlist = NULL;
1588 setprintlist = NULL;
1589 showprintlist = NULL;
1590 setchecklist = NULL;
1591 showchecklist = NULL;
1596 show_info_verbose (struct ui_file *file, int from_tty,
1597 struct cmd_list_element *c,
1601 fprintf_filtered (file,
1602 _("Verbose printing of informational messages is %s.\n"),
1605 fprintf_filtered (file, _("Verbosity is %s.\n"), value);
1609 show_history_expansion_p (struct ui_file *file, int from_tty,
1610 struct cmd_list_element *c, const char *value)
1612 fprintf_filtered (file, _("History expansion on command input is %s.\n"),
1617 show_baud_rate (struct ui_file *file, int from_tty,
1618 struct cmd_list_element *c, const char *value)
1620 fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
1625 show_remote_debug (struct ui_file *file, int from_tty,
1626 struct cmd_list_element *c, const char *value)
1628 fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"),
1633 show_remote_timeout (struct ui_file *file, int from_tty,
1634 struct cmd_list_element *c, const char *value)
1636 fprintf_filtered (file,
1637 _("Timeout limit to wait for target to respond is %s.\n"),
1642 show_max_user_call_depth (struct ui_file *file, int from_tty,
1643 struct cmd_list_element *c, const char *value)
1645 fprintf_filtered (file,
1646 _("The max call depth for user-defined commands is %s.\n"),
1652 init_cli_cmds (void)
1654 struct cmd_list_element *c;
1655 char *source_help_text;
1657 /* Define the classes of commands.
1658 They will appear in the help list in alphabetical order. */
1660 add_cmd ("internals", class_maintenance, NULL, _("\
1661 Maintenance commands.\n\
1662 Some gdb commands are provided just for use by gdb maintainers.\n\
1663 These commands are subject to frequent change, and may not be as\n\
1664 well documented as user commands."),
1666 add_cmd ("obscure", class_obscure, NULL, _("Obscure features."), &cmdlist);
1667 add_cmd ("aliases", class_alias, NULL,
1668 _("Aliases of other commands."), &cmdlist);
1669 add_cmd ("user-defined", class_user, NULL, _("\
1670 User-defined commands.\n\
1671 The commands in this class are those defined by the user.\n\
1672 Use the \"define\" command to define a command."), &cmdlist);
1673 add_cmd ("support", class_support, NULL, _("Support facilities."), &cmdlist);
1675 add_cmd ("status", class_info, NULL, _("Status inquiries."), &cmdlist);
1676 add_cmd ("files", class_files, NULL, _("Specifying and examining files."),
1678 add_cmd ("breakpoints", class_breakpoint, NULL,
1679 _("Making program stop at certain points."), &cmdlist);
1680 add_cmd ("data", class_vars, NULL, _("Examining data."), &cmdlist);
1681 add_cmd ("stack", class_stack, NULL, _("\
1682 Examining the stack.\n\
1683 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1684 counting from zero for the innermost (currently executing) frame.\n\n\
1685 At any time gdb identifies one frame as the \"selected\" frame.\n\
1686 Variable lookups are done with respect to the selected frame.\n\
1687 When the program being debugged stops, gdb selects the innermost frame.\n\
1688 The commands below can be used to select other frames by number or address."),
1690 add_cmd ("running", class_run, NULL, _("Running the program."), &cmdlist);
1692 /* Define general commands. */
1694 add_com ("pwd", class_files, pwd_command, _("\
1695 Print working directory. This is used for your program as well."));
1697 c = add_cmd ("cd", class_files, cd_command, _("\
1698 Set working directory to DIR for debugger and program being debugged.\n\
1699 The change does not take effect for the program being debugged\n\
1700 until the next time it is started."), &cmdlist);
1701 set_cmd_completer (c, filename_completer);
1703 add_com ("echo", class_support, echo_command, _("\
1704 Print a constant string. Give string as argument.\n\
1705 C escape sequences may be used in the argument.\n\
1706 No newline is added at the end of the argument;\n\
1707 use \"\\n\" if you want a newline to be printed.\n\
1708 Since leading and trailing whitespace are ignored in command arguments,\n\
1709 if you want to print some you must use \"\\\" before leading whitespace\n\
1710 to be printed or after trailing whitespace."));
1711 add_com ("document", class_support, document_command, _("\
1712 Document a user-defined command.\n\
1713 Give command name as argument. Give documentation on following lines.\n\
1714 End with a line of just \"end\"."));
1715 add_com ("define", class_support, define_command, _("\
1716 Define a new command name. Command name is argument.\n\
1717 Definition appears on following lines, one command per line.\n\
1718 End with a line of just \"end\".\n\
1719 Use the \"document\" command to give documentation for the new command.\n\
1720 Commands defined in this way may have up to ten arguments."));
1722 source_help_text = xstrprintf (_("\
1723 Read commands from a file named FILE.\n\
1725 Usage: source [-s] [-v] FILE\n\
1726 -s: search for the script in the source search path,\n\
1727 even if FILE contains directories.\n\
1728 -v: each command in FILE is echoed as it is executed.\n\
1730 Note that the file \"%s\" is read automatically in this way\n\
1731 when GDB is started."), gdbinit);
1732 c = add_cmd ("source", class_support, source_command,
1733 source_help_text, &cmdlist);
1734 set_cmd_completer (c, filename_completer);
1736 add_setshow_enum_cmd ("script-extension", class_support,
1737 script_ext_enums, &script_ext_mode, _("\
1738 Set mode for script filename extension recognition."), _("\
1739 Show mode for script filename extension recognition."), _("\
1740 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1741 soft == evaluate script according to filename extension, fallback to GDB script"
1743 strict == evaluate script according to filename extension, error if not supported"
1746 show_script_ext_mode,
1747 &setlist, &showlist);
1749 add_com ("quit", class_support, quit_command, _("Exit gdb."));
1750 c = add_com ("help", class_support, help_command,
1751 _("Print list of commands."));
1752 set_cmd_completer (c, command_completer);
1753 add_com_alias ("q", "quit", class_support, 1);
1754 add_com_alias ("h", "help", class_support, 1);
1756 add_setshow_boolean_cmd ("verbose", class_support, &info_verbose, _("\
1757 Set verbosity."), _("\
1758 Show verbosity."), NULL,
1761 &setlist, &showlist);
1763 add_prefix_cmd ("history", class_support, set_history,
1764 _("Generic command for setting command history parameters."),
1765 &sethistlist, "set history ", 0, &setlist);
1766 add_prefix_cmd ("history", class_support, show_history,
1767 _("Generic command for showing command history parameters."),
1768 &showhistlist, "show history ", 0, &showlist);
1770 add_setshow_boolean_cmd ("expansion", no_class, &history_expansion_p, _("\
1771 Set history expansion on command input."), _("\
1772 Show history expansion on command input."), _("\
1773 Without an argument, history expansion is enabled."),
1775 show_history_expansion_p,
1776 &sethistlist, &showhistlist);
1778 add_prefix_cmd ("info", class_info, info_command, _("\
1779 Generic command for showing things about the program being debugged."),
1780 &infolist, "info ", 0, &cmdlist);
1781 add_com_alias ("i", "info", class_info, 1);
1782 add_com_alias ("inf", "info", class_info, 1);
1784 add_com ("complete", class_obscure, complete_command,
1785 _("List the completions for the rest of the line as a command."));
1787 add_prefix_cmd ("show", class_info, show_command, _("\
1788 Generic command for showing things about the debugger."),
1789 &showlist, "show ", 0, &cmdlist);
1790 /* Another way to get at the same thing. */
1791 add_info ("set", show_command, _("Show all GDB settings."));
1793 add_cmd ("commands", no_set_class, show_commands, _("\
1794 Show the history of commands you typed.\n\
1795 You can supply a command number to start with, or a `+' to start after\n\
1796 the previous command number shown."),
1799 add_cmd ("version", no_set_class, show_version,
1800 _("Show what version of GDB this is."), &showlist);
1802 add_com ("while", class_support, while_command, _("\
1803 Execute nested commands WHILE the conditional expression is non zero.\n\
1804 The conditional expression must follow the word `while' and must in turn be\n\
1805 followed by a new line. The nested commands must be entered one per line,\n\
1806 and should be terminated by the word `end'."));
1808 add_com ("if", class_support, if_command, _("\
1809 Execute nested commands once IF the conditional expression is non zero.\n\
1810 The conditional expression must follow the word `if' and must in turn be\n\
1811 followed by a new line. The nested commands must be entered one per line,\n\
1812 and should be terminated by the word 'else' or `end'. If an else clause\n\
1813 is used, the same rules apply to its nested commands as to the first ones."));
1815 /* If target is open when baud changes, it doesn't take effect until
1816 the next open (I think, not sure). */
1817 add_setshow_zinteger_cmd ("remotebaud", no_class, &baud_rate, _("\
1818 Set baud rate for remote serial I/O."), _("\
1819 Show baud rate for remote serial I/O."), _("\
1820 This value is used to set the speed of the serial port when debugging\n\
1821 using remote targets."),
1824 &setlist, &showlist);
1826 add_setshow_zinteger_cmd ("remote", no_class, &remote_debug, _("\
1827 Set debugging of remote protocol."), _("\
1828 Show debugging of remote protocol."), _("\
1829 When enabled, each packet sent or received with the remote target\n\
1833 &setdebuglist, &showdebuglist);
1835 add_setshow_integer_cmd ("remotetimeout", no_class, &remote_timeout, _("\
1836 Set timeout limit to wait for target to respond."), _("\
1837 Show timeout limit to wait for target to respond."), _("\
1838 This value is used to set the time limit for gdb to wait for a response\n\
1841 show_remote_timeout,
1842 &setlist, &showlist);
1844 add_prefix_cmd ("debug", no_class, set_debug,
1845 _("Generic command for setting gdb debugging flags"),
1846 &setdebuglist, "set debug ", 0, &setlist);
1848 add_prefix_cmd ("debug", no_class, show_debug,
1849 _("Generic command for showing gdb debugging flags"),
1850 &showdebuglist, "show debug ", 0, &showlist);
1852 c = add_com ("shell", class_support, shell_escape, _("\
1853 Execute the rest of the line as a shell command.\n\
1854 With no arguments, run an inferior shell."));
1855 set_cmd_completer (c, filename_completer);
1857 c = add_com ("edit", class_files, edit_command, _("\
1858 Edit specified file or function.\n\
1859 With no argument, edits file containing most recent line listed.\n\
1860 Editing targets can be specified in these ways:\n\
1861 FILE:LINENUM, to edit at that line in that file,\n\
1862 FUNCTION, to edit at the beginning of that function,\n\
1863 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1864 *ADDRESS, to edit at the line containing that address.\n\
1865 Uses EDITOR environment variable contents as editor (or ex as default)."));
1867 c->completer = location_completer;
1869 add_com ("list", class_files, list_command, _("\
1870 List specified function or line.\n\
1871 With no argument, lists ten more lines after or around previous listing.\n\
1872 \"list -\" lists the ten lines before a previous ten-line listing.\n\
1873 One argument specifies a line, and ten lines are listed around that line.\n\
1874 Two arguments with comma between specify starting and ending lines to list.\n\
1875 Lines can be specified in these ways:\n\
1876 LINENUM, to list around that line in current file,\n\
1877 FILE:LINENUM, to list around that line in that file,\n\
1878 FUNCTION, to list around beginning of that function,\n\
1879 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1880 *ADDRESS, to list around the line containing that address.\n\
1881 With two args if one is empty it stands for ten lines away from \
1885 add_com_alias ("l", "list", class_files, 1);
1887 add_com_alias ("v", "list", class_files, 1);
1890 add_com_alias ("file", "list", class_files, 1);
1892 c = add_com ("disassemble", class_vars, disassemble_command, _("\
1893 Disassemble a specified section of memory.\n\
1894 Default is the function surrounding the pc of the selected frame.\n\
1895 With a /m modifier, source lines are included (if available).\n\
1896 With a /r modifier, raw instructions in hex are included.\n\
1897 With a single argument, the function surrounding that address is dumped.\n\
1898 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
1899 in the form of \"start,end\", or \"start,+length\"."));
1900 set_cmd_completer (c, location_completer);
1902 add_com_alias ("va", "disassemble", class_xdb, 0);
1904 add_com_alias ("!", "shell", class_support, 0);
1906 c = add_com ("make", class_support, make_command, _("\
1907 Run the ``make'' program using the rest of the line as arguments."));
1908 set_cmd_completer (c, filename_completer);
1909 add_cmd ("user", no_class, show_user, _("\
1910 Show definitions of user defined commands.\n\
1911 Argument is the name of the user defined command.\n\
1912 With no argument, show definitions of all user defined commands."), &showlist);
1913 add_com ("apropos", class_support, apropos_command,
1914 _("Search for commands matching a REGEXP"));
1916 add_setshow_integer_cmd ("max-user-call-depth", no_class,
1917 &max_user_call_depth, _("\
1918 Set the max call depth for user-defined commands."), _("\
1919 Show the max call depth for user-defined commands."), NULL,
1921 show_max_user_call_depth,
1922 &setlist, &showlist);
1924 add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\
1925 Set tracing of GDB CLI commands."), _("\
1926 Show state of GDB CLI command tracing."), _("\
1927 When 'on', each command is displayed as it is executed."),
1930 &setlist, &showlist);
1932 c = add_com ("alias", class_support, alias_command, _("\
1933 Define a new command that is an alias of an existing command.\n\
1934 Usage: alias [-a] [--] ALIAS = COMMAND\n\
1935 ALIAS is the name of the alias command to create.\n\
1936 COMMAND is the command being aliased to.\n\
1937 If \"-a\" is specified, the command is an abbreviation,\n\
1938 and will not appear in help command list output.\n\
1941 Make \"spe\" an alias of \"set print elements\":\n\
1942 alias spe = set print elements\n\
1943 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
1944 alias -a set print elms = set print elements"));