gdb/cli/cli-cmds.c

   1 /* GDB CLI commands.
   2
   3    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   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.
  12
  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.
  17
  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/>.  */
  20
  21 #include "defs.h"
  22 #include "arch-utils.h"
  23 #include "readline/readline.h"
  24 #include "readline/tilde.h"
  25 #include "completer.h"
  26 #include "target.h"      /* For baud_rate, remote_debug and remote_timeout */
  27 #include "gdb_wait.h"           /* For shell escape implementation */
  28 #include "gdb_regex.h"          /* Used by apropos_command */
  29 #include "gdb_string.h"
  30 #include "gdb_vfork.h"
  31 #include "linespec.h"
  32 #include "expression.h"
  33 #include "frame.h"
  34 #include "value.h"
  35 #include "language.h"
  36 #include "filenames.h"          /* for DOSish file names */
  37 #include "objfiles.h"
  38 #include "source.h"
  39 #include "disasm.h"
  40
  41 #include "ui-out.h"
  42
  43 #include "top.h"
  44 #include "cli/cli-decode.h"
  45 #include "cli/cli-script.h"
  46 #include "cli/cli-setshow.h"
  47 #include "cli/cli-cmds.h"
  48
  49 #ifdef TUI
  50 #include "tui/tui.h"            /* For tui_active et.al.   */
  51 #endif
  52
  53 #include <fcntl.h>
  54
  55 /* Prototypes for local command functions */
  56
  57 static void complete_command (char *, int);
  58
  59 static void echo_command (char *, int);
  60
  61 static void pwd_command (char *, int);
  62
  63 static void show_version (char *, int);
  64
  65 static void help_command (char *, int);
  66
  67 static void show_command (char *, int);
  68
  69 static void info_command (char *, int);
  70
  71 static void show_debug (char *, int);
  72
  73 static void set_debug (char *, int);
  74
  75 static void show_user (char *, int);
  76
  77 static void make_command (char *, int);
  78
  79 static void shell_escape (char *, int);
  80
  81 static void edit_command (char *, int);
  82
  83 static void list_command (char *, int);
  84
  85 void apropos_command (char *, int);
  86
  87 /* Prototypes for local utility functions */
  88
  89 static void ambiguous_line_spec (struct symtabs_and_lines *);
  90 \f
  91 /* Limit the call depth of user-defined commands */
  92 int max_user_call_depth;
  93
  94 /* Define all cmd_list_elements.  */
  95
  96 /* Chain containing all defined commands.  */
  97
  98 struct cmd_list_element *cmdlist;
  99
 100 /* Chain containing all defined info subcommands.  */
 101
 102 struct cmd_list_element *infolist;
 103
 104 /* Chain containing all defined enable subcommands. */
 105
 106 struct cmd_list_element *enablelist;
 107
 108 /* Chain containing all defined disable subcommands. */
 109
 110 struct cmd_list_element *disablelist;
 111
 112 /* Chain containing all defined toggle subcommands. */
 113
 114 struct cmd_list_element *togglelist;
 115
 116 /* Chain containing all defined stop subcommands. */
 117
 118 struct cmd_list_element *stoplist;
 119
 120 /* Chain containing all defined delete subcommands. */
 121
 122 struct cmd_list_element *deletelist;
 123
 124 /* Chain containing all defined detach subcommands. */
 125
 126 struct cmd_list_element *detachlist;
 127
 128 /* Chain containing all defined kill subcommands. */
 129
 130 struct cmd_list_element *killlist;
 131
 132 /* Chain containing all defined "enable breakpoint" subcommands. */
 133
 134 struct cmd_list_element *enablebreaklist;
 135
 136 /* Chain containing all defined set subcommands */
 137
 138 struct cmd_list_element *setlist;
 139
 140 /* Chain containing all defined unset subcommands */
 141
 142 struct cmd_list_element *unsetlist;
 143
 144 /* Chain containing all defined show subcommands.  */
 145
 146 struct cmd_list_element *showlist;
 147
 148 /* Chain containing all defined \"set history\".  */
 149
 150 struct cmd_list_element *sethistlist;
 151
 152 /* Chain containing all defined \"show history\".  */
 153
 154 struct cmd_list_element *showhistlist;
 155
 156 /* Chain containing all defined \"unset history\".  */
 157
 158 struct cmd_list_element *unsethistlist;
 159
 160 /* Chain containing all defined maintenance subcommands. */
 161
 162 struct cmd_list_element *maintenancelist;
 163
 164 /* Chain containing all defined "maintenance info" subcommands. */
 165
 166 struct cmd_list_element *maintenanceinfolist;
 167
 168 /* Chain containing all defined "maintenance print" subcommands. */
 169
 170 struct cmd_list_element *maintenanceprintlist;
 171
 172 struct cmd_list_element *setprintlist;
 173
 174 struct cmd_list_element *showprintlist;
 175
 176 struct cmd_list_element *setdebuglist;
 177
 178 struct cmd_list_element *showdebuglist;
 179
 180 struct cmd_list_element *setchecklist;
 181
 182 struct cmd_list_element *showchecklist;
 183
 184 /* Command tracing state.  */
 185
 186 int source_verbose = 0;
 187 int trace_commands = 0;
 188 \f
 189 /* Utility used everywhere when at least one argument is needed and
 190    none is supplied. */
 191
 192 void
 193 error_no_arg (char *why)
 194 {
 195   error (_("Argument required (%s)."), why);
 196 }
 197
 198 /* The "info" command is defined as a prefix, with allow_unknown = 0.
 199    Therefore, its own definition is called only for "info" with no args.  */
 200
 201 static void
 202 info_command (char *arg, int from_tty)
 203 {
 204   printf_unfiltered (_("\"info\" must be followed by the name of an info command.\n"));
 205   help_list (infolist, "info ", -1, gdb_stdout);
 206 }
 207
 208 /* The "show" command with no arguments shows all the settings.  */
 209
 210 static void
 211 show_command (char *arg, int from_tty)
 212 {
 213   cmd_show_list (showlist, from_tty, "");
 214 }
 215 \f
 216 /* Provide documentation on command or list given by COMMAND.  FROM_TTY
 217    is ignored.  */
 218
 219 static void
 220 help_command (char *command, int from_tty)
 221 {
 222   help_cmd (command, gdb_stdout);
 223 }
 224 \f
 225 /* String compare function for qsort.  */
 226 static int
 227 compare_strings (const void *arg1, const void *arg2)
 228 {
 229   const char **s1 = (const char **) arg1;
 230   const char **s2 = (const char **) arg2;
 231   return strcmp (*s1, *s2);
 232 }
 233
 234 /* The "complete" command is used by Emacs to implement completion.  */
 235
 236 static void
 237 complete_command (char *arg, int from_tty)
 238 {
 239   int i;
 240   int argpoint;
 241   char **completions, *point, *arg_prefix;
 242
 243   dont_repeat ();
 244
 245   if (arg == NULL)
 246     arg = "";
 247   argpoint = strlen (arg);
 248
 249   /* complete_line assumes that its first argument is somewhere within,
 250      and except for filenames at the beginning of, the word to be completed.
 251      The following crude imitation of readline's word-breaking tries to
 252      accomodate this.  */
 253   point = arg + argpoint;
 254   while (point > arg)
 255     {
 256       if (strchr (rl_completer_word_break_characters, point[-1]) != 0)
 257         break;
 258       point--;
 259     }
 260
 261   arg_prefix = alloca (point - arg + 1);
 262   memcpy (arg_prefix, arg, point - arg);
 263   arg_prefix[point - arg] = 0;
 264
 265   completions = complete_line (point, arg, argpoint);
 266
 267   if (completions)
 268     {
 269       int item, size;
 270
 271       for (size = 0; completions[size]; ++size)
 272         ;
 273       qsort (completions, size, sizeof (char *), compare_strings);
 274
 275       /* We do extra processing here since we only want to print each
 276          unique item once.  */
 277       item = 0;
 278       while (item < size)
 279         {
 280           int next_item;
 281           printf_unfiltered ("%s%s\n", arg_prefix, completions[item]);
 282           next_item = item + 1;
 283           while (next_item < size
 284                  && ! strcmp (completions[item], completions[next_item]))
 285             {
 286               xfree (completions[next_item]);
 287               ++next_item;
 288             }
 289
 290           xfree (completions[item]);
 291           item = next_item;
 292         }
 293
 294       xfree (completions);
 295     }
 296 }
 297
 298 int
 299 is_complete_command (struct cmd_list_element *c)
 300 {
 301   return cmd_cfunc_eq (c, complete_command);
 302 }
 303
 304 static void
 305 show_version (char *args, int from_tty)
 306 {
 307   immediate_quit++;
 308   print_gdb_version (gdb_stdout);
 309   printf_filtered ("\n");
 310   immediate_quit--;
 311 }
 312
 313 /* Handle the quit command.  */
 314
 315 void
 316 quit_command (char *args, int from_tty)
 317 {
 318   if (!quit_confirm ())
 319     error (_("Not confirmed."));
 320   quit_force (args, from_tty);
 321 }
 322
 323 static void
 324 pwd_command (char *args, int from_tty)
 325 {
 326   if (args)
 327     error (_("The \"pwd\" command does not take an argument: %s"), args);
 328   if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
 329     error (_("Error finding name of working directory: %s"),
 330            safe_strerror (errno));
 331
 332   if (strcmp (gdb_dirbuf, current_directory) != 0)
 333     printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
 334                        current_directory, gdb_dirbuf);
 335   else
 336     printf_unfiltered (_("Working directory %s.\n"), current_directory);
 337 }
 338
 339 void
 340 cd_command (char *dir, int from_tty)
 341 {
 342   int len;
 343   /* Found something other than leading repetitions of "/..".  */
 344   int found_real_path;
 345   char *p;
 346
 347   /* If the new directory is absolute, repeat is a no-op; if relative,
 348      repeat might be useful but is more likely to be a mistake.  */
 349   dont_repeat ();
 350
 351   if (dir == 0)
 352     error_no_arg (_("new working directory"));
 353
 354   dir = tilde_expand (dir);
 355   make_cleanup (xfree, dir);
 356
 357   if (chdir (dir) < 0)
 358     perror_with_name (dir);
 359
 360 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 361   /* There's too much mess with DOSish names like "d:", "d:.",
 362      "d:./foo" etc.  Instead of having lots of special #ifdef'ed code,
 363      simply get the canonicalized name of the current directory.  */
 364   dir = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 365 #endif
 366
 367   len = strlen (dir);
 368   if (IS_DIR_SEPARATOR (dir[len - 1]))
 369     {
 370       /* Remove the trailing slash unless this is a root directory
 371          (including a drive letter on non-Unix systems).  */
 372       if (!(len == 1)           /* "/" */
 373 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 374           && !(len == 3 && dir[1] == ':') /* "d:/" */
 375 #endif
 376           )
 377         len--;
 378     }
 379
 380   dir = savestring (dir, len);
 381   if (IS_ABSOLUTE_PATH (dir))
 382     current_directory = dir;
 383   else
 384     {
 385       if (IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1]))
 386         current_directory = concat (current_directory, dir, (char *)NULL);
 387       else
 388         current_directory = concat (current_directory, SLASH_STRING,
 389                                     dir, (char *)NULL);
 390       xfree (dir);
 391     }
 392
 393   /* Now simplify any occurrences of `.' and `..' in the pathname.  */
 394
 395   found_real_path = 0;
 396   for (p = current_directory; *p;)
 397     {
 398       if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.'
 399           && (p[2] == 0 || IS_DIR_SEPARATOR (p[2])))
 400         strcpy (p, p + 2);
 401       else if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' && p[2] == '.'
 402                && (p[3] == 0 || IS_DIR_SEPARATOR (p[3])))
 403         {
 404           if (found_real_path)
 405             {
 406               /* Search backwards for the directory just before the "/.."
 407                  and obliterate it and the "/..".  */
 408               char *q = p;
 409               while (q != current_directory && !IS_DIR_SEPARATOR (q[-1]))
 410                 --q;
 411
 412               if (q == current_directory)
 413                 /* current_directory is
 414                    a relative pathname ("can't happen"--leave it alone).  */
 415                 ++p;
 416               else
 417                 {
 418                   strcpy (q - 1, p + 3);
 419                   p = q - 1;
 420                 }
 421             }
 422           else
 423             /* We are dealing with leading repetitions of "/..", for example
 424                "/../..", which is the Mach super-root.  */
 425             p += 3;
 426         }
 427       else
 428         {
 429           found_real_path = 1;
 430           ++p;
 431         }
 432     }
 433
 434   forget_cached_source_info ();
 435
 436   if (from_tty)
 437     pwd_command ((char *) 0, 1);
 438 }
 439 \f
 440 void
 441 source_script (char *file, int from_tty)
 442 {
 443   FILE *stream;
 444   struct cleanup *old_cleanups;
 445   char *full_pathname = NULL;
 446   int fd;
 447
 448   if (file == NULL || *file == 0)
 449     {
 450       error (_("source command requires file name of file to source."));
 451     }
 452
 453   file = tilde_expand (file);
 454   old_cleanups = make_cleanup (xfree, file);
 455
 456   /* Search for and open 'file' on the search path used for source
 457      files.  Put the full location in 'full_pathname'.  */
 458   fd = openp (source_path, OPF_TRY_CWD_FIRST,
 459               file, O_RDONLY, &full_pathname);
 460   make_cleanup (xfree, full_pathname);
 461
 462   /* Use the full path name, if it is found.  */
 463   if (full_pathname != NULL && fd != -1)
 464     {
 465       file = full_pathname;
 466     }
 467
 468   if (fd == -1)
 469     {
 470       if (from_tty)
 471         perror_with_name (file);
 472       else
 473         {
 474           do_cleanups (old_cleanups);
 475           return;
 476         }
 477     }
 478
 479   stream = fdopen (fd, FOPEN_RT);
 480   script_from_file (stream, file);
 481
 482   do_cleanups (old_cleanups);
 483 }
 484
 485 /* Return the source_verbose global variable to its previous state
 486    on exit from the source command, by whatever means.  */
 487 static void
 488 source_verbose_cleanup (void *old_value)
 489 {
 490   source_verbose = *(int *)old_value;
 491   xfree (old_value);
 492 }
 493
 494 static void
 495 source_command (char *args, int from_tty)
 496 {
 497   struct cleanup *old_cleanups;
 498   char *file = args;
 499   int *old_source_verbose = xmalloc (sizeof(int));
 500
 501   *old_source_verbose = source_verbose;
 502   old_cleanups = make_cleanup (source_verbose_cleanup, old_source_verbose);
 503
 504   /* -v causes the source command to run in verbose mode.
 505      We still have to be able to handle filenames with spaces in a
 506      backward compatible way, so buildargv is not appropriate.  */
 507
 508   if (args)
 509     {
 510       /* Make sure leading white space does not break the comparisons.  */
 511       while (isspace(args[0]))
 512         args++;
 513
 514       /* Is -v the first thing in the string?  */
 515       if (args[0] == '-' && args[1] == 'v' && isspace (args[2]))
 516         {
 517           source_verbose = 1;
 518
 519           /* Trim -v and whitespace from the filename.  */
 520           file = &args[3];
 521           while (isspace (file[0]))
 522             file++;
 523         }
 524     }
 525
 526   source_script (file, from_tty);
 527 }
 528
 529
 530 static void
 531 echo_command (char *text, int from_tty)
 532 {
 533   char *p = text;
 534   int c;
 535
 536   if (text)
 537     while ((c = *p++) != '\0')
 538       {
 539         if (c == '\\')
 540           {
 541             /* \ at end of argument is used after spaces
 542                so they won't be lost.  */
 543             if (*p == 0)
 544               return;
 545
 546             c = parse_escape (&p);
 547             if (c >= 0)
 548               printf_filtered ("%c", c);
 549           }
 550         else
 551           printf_filtered ("%c", c);
 552       }
 553
 554   /* Force this output to appear now.  */
 555   wrap_here ("");
 556   gdb_flush (gdb_stdout);
 557 }
 558
 559 static void
 560 shell_escape (char *arg, int from_tty)
 561 {
 562 #if defined(CANT_FORK) || \
 563       (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
 564   /* If ARG is NULL, they want an inferior shell, but `system' just
 565      reports if the shell is available when passed a NULL arg.  */
 566   int rc = system (arg ? arg : "");
 567
 568   if (!arg)
 569     arg = "inferior shell";
 570
 571   if (rc == -1)
 572     {
 573       fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg,
 574                           safe_strerror (errno));
 575       gdb_flush (gdb_stderr);
 576     }
 577   else if (rc)
 578     {
 579       fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc);
 580       gdb_flush (gdb_stderr);
 581     }
 582 #ifdef GLOBAL_CURDIR
 583   /* Make sure to return to the directory GDB thinks it is, in case the
 584      shell command we just ran changed it.  */
 585   chdir (current_directory);
 586 #endif
 587 #else /* Can fork.  */
 588   int rc, status, pid;
 589
 590   if ((pid = vfork ()) == 0)
 591     {
 592       char *p, *user_shell;
 593
 594       if ((user_shell = (char *) getenv ("SHELL")) == NULL)
 595         user_shell = "/bin/sh";
 596
 597       /* Get the name of the shell for arg0 */
 598       if ((p = strrchr (user_shell, '/')) == NULL)
 599         p = user_shell;
 600       else
 601         p++;                    /* Get past '/' */
 602
 603       if (!arg)
 604         execl (user_shell, p, (char *) 0);
 605       else
 606         execl (user_shell, p, "-c", arg, (char *) 0);
 607
 608       fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
 609                           safe_strerror (errno));
 610       gdb_flush (gdb_stderr);
 611       _exit (0177);
 612     }
 613
 614   if (pid != -1)
 615     while ((rc = wait (&status)) != pid && rc != -1)
 616       ;
 617   else
 618     error (_("Fork failed"));
 619 #endif /* Can fork.  */
 620 }
 621
 622 static void
 623 edit_command (char *arg, int from_tty)
 624 {
 625   struct symtabs_and_lines sals;
 626   struct symtab_and_line sal;
 627   struct symbol *sym;
 628   char *arg1;
 629   char *editor;
 630   char *p, *fn;
 631
 632   /* Pull in the current default source line if necessary.  */
 633   if (arg == 0)
 634     {
 635       set_default_source_symtab_and_line ();
 636       sal = get_current_source_symtab_and_line ();
 637     }
 638
 639   /* bare "edit" edits file with present line.  */
 640
 641   if (arg == 0)
 642     {
 643       if (sal.symtab == 0)
 644         error (_("No default source file yet."));
 645       sal.line += get_lines_to_list () / 2;
 646     }
 647   else
 648     {
 649
 650       /* Now should only be one argument -- decode it in SAL.  */
 651
 652       arg1 = arg;
 653       sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
 654
 655       if (! sals.nelts)
 656         {
 657           /*  C++  */
 658           return;
 659         }
 660       if (sals.nelts > 1)
 661         {
 662           ambiguous_line_spec (&sals);
 663           xfree (sals.sals);
 664           return;
 665         }
 666
 667       sal = sals.sals[0];
 668       xfree (sals.sals);
 669
 670       if (*arg1)
 671         error (_("Junk at end of line specification."));
 672
 673       /* If line was specified by address,
 674          first print exactly which line, and which file.
 675          In this case, sal.symtab == 0 means address is outside
 676          of all known source files, not that user failed to give a filename.  */
 677       if (*arg == '*')
 678         {
 679           struct gdbarch *gdbarch;
 680           if (sal.symtab == 0)
 681             /* FIXME-32x64--assumes sal.pc fits in long.  */
 682             error (_("No source file for address %s."),
 683                    hex_string ((unsigned long) sal.pc));
 684
 685           gdbarch = get_objfile_arch (sal.symtab->objfile);
 686           sym = find_pc_function (sal.pc);
 687           if (sym)
 688             printf_filtered ("%s is in %s (%s:%d).\n",
 689                              paddress (gdbarch, sal.pc),
 690                              SYMBOL_PRINT_NAME (sym),
 691                              sal.symtab->filename, sal.line);
 692           else
 693             printf_filtered ("%s is at %s:%d.\n",
 694                              paddress (gdbarch, sal.pc),
 695                              sal.symtab->filename, sal.line);
 696         }
 697
 698       /* If what was given does not imply a symtab, it must be an undebuggable
 699          symbol which means no source code.  */
 700
 701       if (sal.symtab == 0)
 702         error (_("No line number known for %s."), arg);
 703     }
 704
 705   if ((editor = (char *) getenv ("EDITOR")) == NULL)
 706       editor = "/bin/ex";
 707
 708   /* If we don't already know the full absolute file name of the
 709      source file, find it now.  */
 710   if (!sal.symtab->fullname)
 711     {
 712       fn = symtab_to_fullname (sal.symtab);
 713       if (!fn)
 714         fn = "unknown";
 715     }
 716   else
 717     fn = sal.symtab->fullname;
 718
 719   /* Quote the file name, in case it has whitespace or other special
 720      characters.  */
 721   p = xstrprintf ("%s +%d \"%s\"", editor, sal.line, fn);
 722   shell_escape (p, from_tty);
 723   xfree (p);
 724 }
 725
 726 static void
 727 list_command (char *arg, int from_tty)
 728 {
 729   struct symtabs_and_lines sals, sals_end;
 730   struct symtab_and_line sal = { 0 };
 731   struct symtab_and_line sal_end = { 0 };
 732   struct symtab_and_line cursal = { 0 };
 733   struct symbol *sym;
 734   char *arg1;
 735   int no_end = 1;
 736   int dummy_end = 0;
 737   int dummy_beg = 0;
 738   int linenum_beg = 0;
 739   char *p;
 740
 741   /* Pull in the current default source line if necessary */
 742   if (arg == 0 || arg[0] == '+' || arg[0] == '-')
 743     {
 744       set_default_source_symtab_and_line ();
 745       cursal = get_current_source_symtab_and_line ();
 746     }
 747
 748   /* "l" or "l +" lists next ten lines.  */
 749
 750   if (arg == 0 || strcmp (arg, "+") == 0)
 751     {
 752       print_source_lines (cursal.symtab, cursal.line,
 753                           cursal.line + get_lines_to_list (), 0);
 754       return;
 755     }
 756
 757   /* "l -" lists previous ten lines, the ones before the ten just listed.  */
 758   if (strcmp (arg, "-") == 0)
 759     {
 760       print_source_lines (cursal.symtab,
 761                           max (get_first_line_listed () - get_lines_to_list (), 1),
 762                           get_first_line_listed (), 0);
 763       return;
 764     }
 765
 766   /* Now if there is only one argument, decode it in SAL
 767      and set NO_END.
 768      If there are two arguments, decode them in SAL and SAL_END
 769      and clear NO_END; however, if one of the arguments is blank,
 770      set DUMMY_BEG or DUMMY_END to record that fact.  */
 771
 772   if (!have_full_symbols () && !have_partial_symbols ())
 773     error (_("No symbol table is loaded.  Use the \"file\" command."));
 774
 775   arg1 = arg;
 776   if (*arg1 == ',')
 777     dummy_beg = 1;
 778   else
 779     {
 780       sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
 781
 782       if (!sals.nelts)
 783         return;                 /*  C++  */
 784       if (sals.nelts > 1)
 785         {
 786           ambiguous_line_spec (&sals);
 787           xfree (sals.sals);
 788           return;
 789         }
 790
 791       sal = sals.sals[0];
 792       xfree (sals.sals);
 793     }
 794
 795   /* Record whether the BEG arg is all digits.  */
 796
 797   for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
 798   linenum_beg = (p == arg1);
 799
 800   while (*arg1 == ' ' || *arg1 == '\t')
 801     arg1++;
 802   if (*arg1 == ',')
 803     {
 804       no_end = 0;
 805       arg1++;
 806       while (*arg1 == ' ' || *arg1 == '\t')
 807         arg1++;
 808       if (*arg1 == 0)
 809         dummy_end = 1;
 810       else
 811         {
 812           if (dummy_beg)
 813             sals_end = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
 814           else
 815             sals_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line, 0, 0);
 816           if (sals_end.nelts == 0)
 817             return;
 818           if (sals_end.nelts > 1)
 819             {
 820               ambiguous_line_spec (&sals_end);
 821               xfree (sals_end.sals);
 822               return;
 823             }
 824           sal_end = sals_end.sals[0];
 825           xfree (sals_end.sals);
 826         }
 827     }
 828
 829   if (*arg1)
 830     error (_("Junk at end of line specification."));
 831
 832   if (!no_end && !dummy_beg && !dummy_end
 833       && sal.symtab != sal_end.symtab)
 834     error (_("Specified start and end are in different files."));
 835   if (dummy_beg && dummy_end)
 836     error (_("Two empty args do not say what lines to list."));
 837
 838   /* if line was specified by address,
 839      first print exactly which line, and which file.
 840      In this case, sal.symtab == 0 means address is outside
 841      of all known source files, not that user failed to give a filename.  */
 842   if (*arg == '*')
 843     {
 844       struct gdbarch *gdbarch;
 845       if (sal.symtab == 0)
 846         /* FIXME-32x64--assumes sal.pc fits in long.  */
 847         error (_("No source file for address %s."),
 848                hex_string ((unsigned long) sal.pc));
 849
 850       gdbarch = get_objfile_arch (sal.symtab->objfile);
 851       sym = find_pc_function (sal.pc);
 852       if (sym)
 853         printf_filtered ("%s is in %s (%s:%d).\n",
 854                          paddress (gdbarch, sal.pc),
 855                          SYMBOL_PRINT_NAME (sym),
 856                          sal.symtab->filename, sal.line);
 857       else
 858         printf_filtered ("%s is at %s:%d.\n",
 859                          paddress (gdbarch, sal.pc),
 860                          sal.symtab->filename, sal.line);
 861     }
 862
 863   /* If line was not specified by just a line number,
 864      and it does not imply a symtab, it must be an undebuggable symbol
 865      which means no source code.  */
 866
 867   if (!linenum_beg && sal.symtab == 0)
 868     error (_("No line number known for %s."), arg);
 869
 870   /* If this command is repeated with RET,
 871      turn it into the no-arg variant.  */
 872
 873   if (from_tty)
 874     *arg = 0;
 875
 876   if (dummy_beg && sal_end.symtab == 0)
 877     error (_("No default source file yet.  Do \"help list\"."));
 878   if (dummy_beg)
 879     print_source_lines (sal_end.symtab,
 880                         max (sal_end.line - (get_lines_to_list () - 1), 1),
 881                         sal_end.line + 1, 0);
 882   else if (sal.symtab == 0)
 883     error (_("No default source file yet.  Do \"help list\"."));
 884   else if (no_end)
 885     {
 886       int first_line = sal.line - get_lines_to_list () / 2;
 887
 888       if (first_line < 1) first_line = 1;
 889
 890       print_source_lines (sal.symtab,
 891                           first_line,
 892                           first_line + get_lines_to_list (),
 893                           0);
 894     }
 895   else
 896     print_source_lines (sal.symtab, sal.line,
 897                         (dummy_end
 898                          ? sal.line + get_lines_to_list ()
 899                          : sal_end.line + 1),
 900                         0);
 901 }
 902
 903 /* Subroutine of disassemble_command to simplify it.
 904    Perform the disassembly.
 905    NAME is the name of the function if known, or NULL.
 906    [LOW,HIGH) are the range of addresses to disassemble.
 907    MIXED is non-zero to print source with the assembler.  */
 908
 909 static void
 910 print_disassembly (struct gdbarch *gdbarch, const char *name,
 911                    CORE_ADDR low, CORE_ADDR high, int flags)
 912 {
 913 #if defined(TUI)
 914   if (!tui_is_window_visible (DISASSEM_WIN))
 915 #endif
 916     {
 917       printf_filtered ("Dump of assembler code ");
 918       if (name != NULL)
 919         printf_filtered ("for function %s:\n", name);
 920       else
 921         printf_filtered ("from %s to %s:\n",
 922                          paddress (gdbarch, low), paddress (gdbarch, high));
 923
 924       /* Dump the specified range.  */
 925       gdb_disassembly (gdbarch, uiout, 0, flags, -1, low, high);
 926
 927       printf_filtered ("End of assembler dump.\n");
 928       gdb_flush (gdb_stdout);
 929     }
 930 #if defined(TUI)
 931   else
 932     {
 933       tui_show_assembly (gdbarch, low);
 934     }
 935 #endif
 936 }
 937
 938 /* Subroutine of disassemble_command to simplify it.
 939    Print a disassembly of the current function according to FLAGS.  */
 940
 941 static void
 942 disassemble_current_function (int flags)
 943 {
 944   struct frame_info *frame;
 945   struct gdbarch *gdbarch;
 946   CORE_ADDR low, high, pc;
 947   char *name;
 948
 949   frame = get_selected_frame (_("No frame selected."));
 950   gdbarch = get_frame_arch (frame);
 951   pc = get_frame_pc (frame);
 952   if (find_pc_partial_function (pc, &name, &low, &high) == 0)
 953     error (_("No function contains program counter for selected frame."));
 954 #if defined(TUI)
 955   /* NOTE: cagney/2003-02-13 The `tui_active' was previously
 956      `tui_version'.  */
 957   if (tui_active)
 958     /* FIXME: cagney/2004-02-07: This should be an observer.  */
 959     low = tui_get_low_disassembly_address (gdbarch, low, pc);
 960 #endif
 961   low += gdbarch_deprecated_function_start_offset (gdbarch);
 962
 963   print_disassembly (gdbarch, name, low, high, flags);
 964 }
 965
 966 /* Dump a specified section of assembly code.
 967
 968    Usage:
 969      disassemble [/mr]
 970        - dump the assembly code for the function of the current pc
 971      disassemble [/mr] addr
 972        - dump the assembly code for the function at ADDR
 973      disassemble [/mr] low high
 974        - dump the assembly code in the range [LOW,HIGH)
 975
 976    A /m modifier will include source code with the assembly.
 977    A /r modifier will include raw instructions in hex with the assembly.  */
 978
 979 static void
 980 disassemble_command (char *arg, int from_tty)
 981 {
 982   struct gdbarch *gdbarch = get_current_arch ();
 983   CORE_ADDR low, high;
 984   char *name;
 985   CORE_ADDR pc, pc_masked;
 986   int flags;
 987
 988   name = NULL;
 989   flags = 0;
 990
 991   if (arg && *arg == '/')
 992     {
 993       ++arg;
 994
 995       if (*arg == '\0')
 996         error (_("Missing modifier."));
 997
 998       while (*arg && ! isspace (*arg))
 999         {
1000           switch (*arg++)
1001             {
1002             case 'm':
1003               flags |= DISASSEMBLY_SOURCE;
1004               break;
1005             case 'r':
1006               flags |= DISASSEMBLY_RAW_INSN;
1007               break;
1008             default:
1009               error (_("Invalid disassembly modifier."));
1010             }
1011         }
1012
1013       while (isspace (*arg))
1014         ++arg;
1015     }
1016
1017   if (! arg || ! *arg)
1018     {
1019       flags |= DISASSEMBLY_OMIT_FNAME;
1020       disassemble_current_function (flags);
1021       return;
1022     }
1023
1024   pc = value_as_address (parse_to_comma_and_eval (&arg));
1025   if (arg[0] == ',')
1026     ++arg;
1027   if (arg[0] == '\0')
1028     {
1029       /* One argument.  */
1030       if (find_pc_partial_function (pc, &name, &low, &high) == 0)
1031         error (_("No function contains specified address."));
1032 #if defined(TUI)
1033       /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1034          `tui_version'.  */
1035       if (tui_active)
1036         /* FIXME: cagney/2004-02-07: This should be an observer.  */
1037         low = tui_get_low_disassembly_address (gdbarch, low, pc);
1038 #endif
1039       low += gdbarch_deprecated_function_start_offset (gdbarch);
1040       flags |= DISASSEMBLY_OMIT_FNAME;
1041     }
1042   else
1043     {
1044       /* Two arguments.  */
1045       low = pc;
1046       high = parse_and_eval_address (arg);
1047     }
1048
1049   print_disassembly (gdbarch, name, low, high, flags);
1050 }
1051
1052 static void
1053 make_command (char *arg, int from_tty)
1054 {
1055   char *p;
1056
1057   if (arg == 0)
1058     p = "make";
1059   else
1060     {
1061       p = xmalloc (sizeof ("make ") + strlen (arg));
1062       strcpy (p, "make ");
1063       strcpy (p + sizeof ("make ") - 1, arg);
1064     }
1065
1066   shell_escape (p, from_tty);
1067 }
1068
1069 static void
1070 show_user (char *args, int from_tty)
1071 {
1072   struct cmd_list_element *c;
1073   extern struct cmd_list_element *cmdlist;
1074
1075   if (args)
1076     {
1077       char *comname = args;
1078       c = lookup_cmd (&comname, cmdlist, "", 0, 1);
1079       if (c->class != class_user)
1080         error (_("Not a user command."));
1081       show_user_1 (c, "", args, gdb_stdout);
1082     }
1083   else
1084     {
1085       for (c = cmdlist; c; c = c->next)
1086         {
1087           if (c->class == class_user || c->prefixlist != NULL)
1088             show_user_1 (c, "", c->name, gdb_stdout);
1089         }
1090     }
1091 }
1092
1093 /* Search through names of commands and documentations for a certain
1094    regular expression.
1095 */
1096 void
1097 apropos_command (char *searchstr, int from_tty)
1098 {
1099   extern struct cmd_list_element *cmdlist; /*This is the main command list*/
1100   regex_t pattern;
1101   char *pattern_fastmap;
1102   char errorbuffer[512];
1103   pattern_fastmap = xcalloc (256, sizeof (char));
1104   if (searchstr == NULL)
1105       error (_("REGEXP string is empty"));
1106
1107   if (regcomp(&pattern,searchstr,REG_ICASE) == 0)
1108     {
1109       pattern.fastmap=pattern_fastmap;
1110       re_compile_fastmap(&pattern);
1111       apropos_cmd (gdb_stdout,cmdlist,&pattern,"");
1112     }
1113   else
1114     {
1115       regerror(regcomp(&pattern,searchstr,REG_ICASE),NULL,errorbuffer,512);
1116       error (_("Error in regular expression:%s"),errorbuffer);
1117     }
1118   xfree (pattern_fastmap);
1119 }
1120 \f
1121 /* Print a list of files and line numbers which a user may choose from
1122    in order to list a function which was specified ambiguously (as with
1123    `list classname::overloadedfuncname', for example).  The vector in
1124    SALS provides the filenames and line numbers.  */
1125
1126 static void
1127 ambiguous_line_spec (struct symtabs_and_lines *sals)
1128 {
1129   int i;
1130
1131   for (i = 0; i < sals->nelts; ++i)
1132     printf_filtered (_("file: \"%s\", line number: %d\n"),
1133                      sals->sals[i].symtab->filename, sals->sals[i].line);
1134 }
1135
1136 static void
1137 set_debug (char *arg, int from_tty)
1138 {
1139   printf_unfiltered (_("\"set debug\" must be followed by the name of a debug subcommand.\n"));
1140   help_list (setdebuglist, "set debug ", -1, gdb_stdout);
1141 }
1142
1143 static void
1144 show_debug (char *args, int from_tty)
1145 {
1146   cmd_show_list (showdebuglist, from_tty, "");
1147 }
1148
1149 void
1150 init_cmd_lists (void)
1151 {
1152   max_user_call_depth = 1024;
1153
1154   cmdlist = NULL;
1155   infolist = NULL;
1156   enablelist = NULL;
1157   disablelist = NULL;
1158   togglelist = NULL;
1159   stoplist = NULL;
1160   deletelist = NULL;
1161   detachlist = NULL;
1162   enablebreaklist = NULL;
1163   setlist = NULL;
1164   unsetlist = NULL;
1165   showlist = NULL;
1166   sethistlist = NULL;
1167   showhistlist = NULL;
1168   unsethistlist = NULL;
1169   maintenancelist = NULL;
1170   maintenanceinfolist = NULL;
1171   maintenanceprintlist = NULL;
1172   setprintlist = NULL;
1173   showprintlist = NULL;
1174   setchecklist = NULL;
1175   showchecklist = NULL;
1176 }
1177
1178 static void
1179 show_info_verbose (struct ui_file *file, int from_tty,
1180                    struct cmd_list_element *c,
1181                    const char *value)
1182 {
1183   if (info_verbose)
1184     fprintf_filtered (file, _("\
1185 Verbose printing of informational messages is %s.\n"), value);
1186   else
1187     fprintf_filtered (file, _("Verbosity is %s.\n"), value);
1188 }
1189
1190 static void
1191 show_history_expansion_p (struct ui_file *file, int from_tty,
1192                           struct cmd_list_element *c, const char *value)
1193 {
1194   fprintf_filtered (file, _("History expansion on command input is %s.\n"),
1195                     value);
1196 }
1197
1198 static void
1199 show_baud_rate (struct ui_file *file, int from_tty,
1200                 struct cmd_list_element *c, const char *value)
1201 {
1202   fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
1203                     value);
1204 }
1205
1206 static void
1207 show_remote_debug (struct ui_file *file, int from_tty,
1208                    struct cmd_list_element *c, const char *value)
1209 {
1210   fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"),
1211                     value);
1212 }
1213
1214 static void
1215 show_remote_timeout (struct ui_file *file, int from_tty,
1216                      struct cmd_list_element *c, const char *value)
1217 {
1218   fprintf_filtered (file, _("\
1219 Timeout limit to wait for target to respond is %s.\n"),
1220                     value);
1221 }
1222
1223 static void
1224 show_max_user_call_depth (struct ui_file *file, int from_tty,
1225                           struct cmd_list_element *c, const char *value)
1226 {
1227   fprintf_filtered (file, _("\
1228 The max call depth for user-defined commands is %s.\n"),
1229                     value);
1230 }
1231
1232 \f
1233 void
1234 init_cli_cmds (void)
1235 {
1236   struct cmd_list_element *c;
1237   char *source_help_text;
1238
1239   /* Define the classes of commands.
1240      They will appear in the help list in the reverse of this order.  */
1241
1242   add_cmd ("internals", class_maintenance, NULL, _("\
1243 Maintenance commands.\n\
1244 Some gdb commands are provided just for use by gdb maintainers.\n\
1245 These commands are subject to frequent change, and may not be as\n\
1246 well documented as user commands."),
1247            &cmdlist);
1248   add_cmd ("obscure", class_obscure, NULL, _("Obscure features."), &cmdlist);
1249   add_cmd ("aliases", class_alias, NULL, _("Aliases of other commands."), &cmdlist);
1250   add_cmd ("user-defined", class_user, NULL, _("\
1251 User-defined commands.\n\
1252 The commands in this class are those defined by the user.\n\
1253 Use the \"define\" command to define a command."), &cmdlist);
1254   add_cmd ("support", class_support, NULL, _("Support facilities."), &cmdlist);
1255   if (!dbx_commands)
1256     add_cmd ("status", class_info, NULL, _("Status inquiries."), &cmdlist);
1257   add_cmd ("files", class_files, NULL, _("Specifying and examining files."),
1258            &cmdlist);
1259   add_cmd ("breakpoints", class_breakpoint, NULL,
1260            _("Making program stop at certain points."), &cmdlist);
1261   add_cmd ("data", class_vars, NULL, _("Examining data."), &cmdlist);
1262   add_cmd ("stack", class_stack, NULL, _("\
1263 Examining the stack.\n\
1264 The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
1265 counting from zero for the innermost (currently executing) frame.\n\n\
1266 At any time gdb identifies one frame as the \"selected\" frame.\n\
1267 Variable lookups are done with respect to the selected frame.\n\
1268 When the program being debugged stops, gdb selects the innermost frame.\n\
1269 The commands below can be used to select other frames by number or address."),
1270            &cmdlist);
1271   add_cmd ("running", class_run, NULL, _("Running the program."), &cmdlist);
1272
1273   /* Define general commands. */
1274
1275   add_com ("pwd", class_files, pwd_command, _("\
1276 Print working directory.  This is used for your program as well."));
1277
1278   c = add_cmd ("cd", class_files, cd_command, _("\
1279 Set working directory to DIR for debugger and program being debugged.\n\
1280 The change does not take effect for the program being debugged\n\
1281 until the next time it is started."), &cmdlist);
1282   set_cmd_completer (c, filename_completer);
1283
1284   add_com ("echo", class_support, echo_command, _("\
1285 Print a constant string.  Give string as argument.\n\
1286 C escape sequences may be used in the argument.\n\
1287 No newline is added at the end of the argument;\n\
1288 use \"\\n\" if you want a newline to be printed.\n\
1289 Since leading and trailing whitespace are ignored in command arguments,\n\
1290 if you want to print some you must use \"\\\" before leading whitespace\n\
1291 to be printed or after trailing whitespace."));
1292   add_com ("document", class_support, document_command, _("\
1293 Document a user-defined command.\n\
1294 Give command name as argument.  Give documentation on following lines.\n\
1295 End with a line of just \"end\"."));
1296   add_com ("define", class_support, define_command, _("\
1297 Define a new command name.  Command name is argument.\n\
1298 Definition appears on following lines, one command per line.\n\
1299 End with a line of just \"end\".\n\
1300 Use the \"document\" command to give documentation for the new command.\n\
1301 Commands defined in this way may have up to ten arguments."));
1302
1303   source_help_text = xstrprintf (_("\
1304 Read commands from a file named FILE.\n\
1305 Optional -v switch (before the filename) causes each command in\n\
1306 FILE to be echoed as it is executed.\n\
1307 Note that the file \"%s\" is read automatically in this way\n\
1308 when GDB is started."), gdbinit);
1309   c = add_cmd ("source", class_support, source_command,
1310                source_help_text, &cmdlist);
1311   set_cmd_completer (c, filename_completer);
1312
1313   add_com ("quit", class_support, quit_command, _("Exit gdb."));
1314   c = add_com ("help", class_support, help_command,
1315                _("Print list of commands."));
1316   set_cmd_completer (c, command_completer);
1317   add_com_alias ("q", "quit", class_support, 1);
1318   add_com_alias ("h", "help", class_support, 1);
1319
1320   add_setshow_boolean_cmd ("verbose", class_support, &info_verbose, _("\
1321 Set verbosity."), _("\
1322 Show verbosity."), NULL,
1323                            set_verbose,
1324                            show_info_verbose,
1325                            &setlist, &showlist);
1326
1327   add_prefix_cmd ("history", class_support, set_history,
1328                   _("Generic command for setting command history parameters."),
1329                   &sethistlist, "set history ", 0, &setlist);
1330   add_prefix_cmd ("history", class_support, show_history,
1331                   _("Generic command for showing command history parameters."),
1332                   &showhistlist, "show history ", 0, &showlist);
1333
1334   add_setshow_boolean_cmd ("expansion", no_class, &history_expansion_p, _("\
1335 Set history expansion on command input."), _("\
1336 Show history expansion on command input."), _("\
1337 Without an argument, history expansion is enabled."),
1338                            NULL,
1339                            show_history_expansion_p,
1340                            &sethistlist, &showhistlist);
1341
1342   add_prefix_cmd ("info", class_info, info_command, _("\
1343 Generic command for showing things about the program being debugged."),
1344                   &infolist, "info ", 0, &cmdlist);
1345   add_com_alias ("i", "info", class_info, 1);
1346   add_com_alias ("inf", "info", class_info, 1);
1347
1348   add_com ("complete", class_obscure, complete_command,
1349            _("List the completions for the rest of the line as a command."));
1350
1351   add_prefix_cmd ("show", class_info, show_command, _("\
1352 Generic command for showing things about the debugger."),
1353                   &showlist, "show ", 0, &cmdlist);
1354   /* Another way to get at the same thing.  */
1355   add_info ("set", show_command, _("Show all GDB settings."));
1356
1357   add_cmd ("commands", no_class, show_commands, _("\
1358 Show the history of commands you typed.\n\
1359 You can supply a command number to start with, or a `+' to start after\n\
1360 the previous command number shown."),
1361            &showlist);
1362
1363   add_cmd ("version", no_class, show_version,
1364            _("Show what version of GDB this is."), &showlist);
1365
1366   add_com ("while", class_support, while_command, _("\
1367 Execute nested commands WHILE the conditional expression is non zero.\n\
1368 The conditional expression must follow the word `while' and must in turn be\n\
1369 followed by a new line.  The nested commands must be entered one per line,\n\
1370 and should be terminated by the word `end'."));
1371
1372   add_com ("if", class_support, if_command, _("\
1373 Execute nested commands once IF the conditional expression is non zero.\n\
1374 The conditional expression must follow the word `if' and must in turn be\n\
1375 followed by a new line.  The nested commands must be entered one per line,\n\
1376 and should be terminated by the word 'else' or `end'.  If an else clause\n\
1377 is used, the same rules apply to its nested commands as to the first ones."));
1378
1379   /* If target is open when baud changes, it doesn't take effect until the
1380      next open (I think, not sure).  */
1381   add_setshow_zinteger_cmd ("remotebaud", no_class, &baud_rate, _("\
1382 Set baud rate for remote serial I/O."), _("\
1383 Show baud rate for remote serial I/O."), _("\
1384 This value is used to set the speed of the serial port when debugging\n\
1385 using remote targets."),
1386                             NULL,
1387                             show_baud_rate,
1388                             &setlist, &showlist);
1389
1390   add_setshow_zinteger_cmd ("remote", no_class, &remote_debug, _("\
1391 Set debugging of remote protocol."), _("\
1392 Show debugging of remote protocol."), _("\
1393 When enabled, each packet sent or received with the remote target\n\
1394 is displayed."),
1395                             NULL,
1396                             show_remote_debug,
1397                             &setdebuglist, &showdebuglist);
1398
1399   add_setshow_integer_cmd ("remotetimeout", no_class, &remote_timeout, _("\
1400 Set timeout limit to wait for target to respond."), _("\
1401 Show timeout limit to wait for target to respond."), _("\
1402 This value is used to set the time limit for gdb to wait for a response\n\
1403 from the target."),
1404                            NULL,
1405                            show_remote_timeout,
1406                            &setlist, &showlist);
1407
1408   add_prefix_cmd ("debug", no_class, set_debug,
1409                   _("Generic command for setting gdb debugging flags"),
1410                   &setdebuglist, "set debug ", 0, &setlist);
1411
1412   add_prefix_cmd ("debug", no_class, show_debug,
1413                   _("Generic command for showing gdb debugging flags"),
1414                   &showdebuglist, "show debug ", 0, &showlist);
1415
1416   c = add_com ("shell", class_support, shell_escape, _("\
1417 Execute the rest of the line as a shell command.\n\
1418 With no arguments, run an inferior shell."));
1419   set_cmd_completer (c, filename_completer);
1420
1421   c = add_com ("edit", class_files, edit_command, _("\
1422 Edit specified file or function.\n\
1423 With no argument, edits file containing most recent line listed.\n\
1424 Editing targets can be specified in these ways:\n\
1425   FILE:LINENUM, to edit at that line in that file,\n\
1426   FUNCTION, to edit at the beginning of that function,\n\
1427   FILE:FUNCTION, to distinguish among like-named static functions.\n\
1428   *ADDRESS, to edit at the line containing that address.\n\
1429 Uses EDITOR environment variable contents as editor (or ex as default)."));
1430
1431   c->completer = location_completer;
1432
1433   add_com ("list", class_files, list_command, _("\
1434 List specified function or line.\n\
1435 With no argument, lists ten more lines after or around previous listing.\n\
1436 \"list -\" lists the ten lines before a previous ten-line listing.\n\
1437 One argument specifies a line, and ten lines are listed around that line.\n\
1438 Two arguments with comma between specify starting and ending lines to list.\n\
1439 Lines can be specified in these ways:\n\
1440   LINENUM, to list around that line in current file,\n\
1441   FILE:LINENUM, to list around that line in that file,\n\
1442   FUNCTION, to list around beginning of that function,\n\
1443   FILE:FUNCTION, to distinguish among like-named static functions.\n\
1444   *ADDRESS, to list around the line containing that address.\n\
1445 With two args if one is empty it stands for ten lines away from the other arg."));
1446
1447   if (!xdb_commands)
1448     add_com_alias ("l", "list", class_files, 1);
1449   else
1450     add_com_alias ("v", "list", class_files, 1);
1451
1452   if (dbx_commands)
1453     add_com_alias ("file", "list", class_files, 1);
1454
1455   c = add_com ("disassemble", class_vars, disassemble_command, _("\
1456 Disassemble a specified section of memory.\n\
1457 Default is the function surrounding the pc of the selected frame.\n\
1458 With a /m modifier, source lines are included (if available).\n\
1459 With a /r modifier, raw instructions in hex are included.\n\
1460 With a single argument, the function surrounding that address is dumped.\n\
1461 Two arguments (separated by a comma) are taken as a range of memory to dump."));
1462   set_cmd_completer (c, location_completer);
1463   if (xdb_commands)
1464     add_com_alias ("va", "disassemble", class_xdb, 0);
1465
1466   /* NOTE: cagney/2000-03-20: Being able to enter ``(gdb) !ls'' would
1467      be a really useful feature.  Unfortunately, the below wont do
1468      this.  Instead it adds support for the form ``(gdb) ! ls''
1469      (i.e. the space is required).  If the ``!'' command below is
1470      added the complains about no ``!'' command would be replaced by
1471      complains about how the ``!'' command is broken :-) */
1472   if (xdb_commands)
1473     add_com_alias ("!", "shell", class_support, 0);
1474
1475   c = add_com ("make", class_support, make_command, _("\
1476 Run the ``make'' program using the rest of the line as arguments."));
1477   set_cmd_completer (c, filename_completer);
1478   add_cmd ("user", no_class, show_user, _("\
1479 Show definitions of user defined commands.\n\
1480 Argument is the name of the user defined command.\n\
1481 With no argument, show definitions of all user defined commands."), &showlist);
1482   add_com ("apropos", class_support, apropos_command,
1483            _("Search for commands matching a REGEXP"));
1484
1485   add_setshow_integer_cmd ("max-user-call-depth", no_class,
1486                            &max_user_call_depth, _("\
1487 Set the max call depth for user-defined commands."), _("\
1488 Show the max call depth for user-defined commands."), NULL,
1489                            NULL,
1490                            show_max_user_call_depth,
1491                            &setlist, &showlist);
1492
1493   add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\
1494 Set tracing of GDB CLI commands."), _("\
1495 Show state of GDB CLI command tracing."), _("\
1496 When 'on', each command is displayed as it is executed."),
1497                            NULL,
1498                            NULL,
1499                            &setlist, &showlist);
1500 }