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 mixed)
 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, mixed, -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.
 940    MIXED is non-zero to print source with the assembler.  */
 941
 942 static void
 943 disassemble_current_function (int mixed)
 944 {
 945   struct frame_info *frame;
 946   struct gdbarch *gdbarch;
 947   CORE_ADDR low, high, pc;
 948   char *name;
 949
 950   frame = get_selected_frame (_("No frame selected."));
 951   gdbarch = get_frame_arch (frame);
 952   pc = get_frame_pc (frame);
 953   if (find_pc_partial_function (pc, &name, &low, &high) == 0)
 954     error (_("No function contains program counter for selected frame."));
 955 #if defined(TUI)
 956   /* NOTE: cagney/2003-02-13 The `tui_active' was previously
 957      `tui_version'.  */
 958   if (tui_active)
 959     /* FIXME: cagney/2004-02-07: This should be an observer.  */
 960     low = tui_get_low_disassembly_address (gdbarch, low, pc);
 961 #endif
 962   low += gdbarch_deprecated_function_start_offset (gdbarch);
 963
 964   print_disassembly (gdbarch, name, low, high, mixed);
 965 }
 966
 967 /* Dump a specified section of assembly code.
 968
 969    Usage:
 970      disassemble [/m]
 971        - dump the assembly code for the function of the current pc
 972      disassemble [/m] addr
 973        - dump the assembly code for the function at ADDR
 974      disassemble [/m] low high
 975        - dump the assembly code in the range [LOW,HIGH)
 976
 977    A /m modifier will include source code 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   char *space_index;
 987   int mixed_source_and_assembly;
 988
 989   name = NULL;
 990   mixed_source_and_assembly = 0;
 991
 992   if (arg && *arg == '/')
 993     {
 994       ++arg;
 995
 996       if (*arg == '\0')
 997         error (_("Missing modifier."));
 998
 999       while (*arg && ! isspace (*arg))
1000         {
1001           switch (*arg++)
1002             {
1003             case 'm':
1004               mixed_source_and_assembly = 1;
1005               break;
1006             default:
1007               error (_("Invalid disassembly modifier."));
1008             }
1009         }
1010
1011       while (isspace (*arg))
1012         ++arg;
1013     }
1014
1015   if (! arg || ! *arg)
1016     {
1017       disassemble_current_function (mixed_source_and_assembly);
1018       return;
1019     }
1020
1021   /* FIXME: 'twould be nice to allow spaces in the expression for the first
1022      arg.  Allow comma separater too?  */
1023
1024   if (!(space_index = (char *) strchr (arg, ' ')))
1025     {
1026       /* One argument.  */
1027       pc = parse_and_eval_address (arg);
1028       if (find_pc_partial_function (pc, &name, &low, &high) == 0)
1029         error (_("No function contains specified address."));
1030 #if defined(TUI)
1031       /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1032          `tui_version'.  */
1033       if (tui_active)
1034         /* FIXME: cagney/2004-02-07: This should be an observer.  */
1035         low = tui_get_low_disassembly_address (gdbarch, low, pc);
1036 #endif
1037       low += gdbarch_deprecated_function_start_offset (gdbarch);
1038     }
1039   else
1040     {
1041       /* Two arguments.  */
1042       *space_index = '\0';
1043       low = parse_and_eval_address (arg);
1044       high = parse_and_eval_address (space_index + 1);
1045     }
1046
1047   print_disassembly (gdbarch, name, low, high, mixed_source_and_assembly);
1048 }
1049
1050 static void
1051 make_command (char *arg, int from_tty)
1052 {
1053   char *p;
1054
1055   if (arg == 0)
1056     p = "make";
1057   else
1058     {
1059       p = xmalloc (sizeof ("make ") + strlen (arg));
1060       strcpy (p, "make ");
1061       strcpy (p + sizeof ("make ") - 1, arg);
1062     }
1063
1064   shell_escape (p, from_tty);
1065 }
1066
1067 static void
1068 show_user (char *args, int from_tty)
1069 {
1070   struct cmd_list_element *c;
1071   extern struct cmd_list_element *cmdlist;
1072
1073   if (args)
1074     {
1075       char *comname = args;
1076       c = lookup_cmd (&comname, cmdlist, "", 0, 1);
1077       if (c->class != class_user)
1078         error (_("Not a user command."));
1079       show_user_1 (c, "", args, gdb_stdout);
1080     }
1081   else
1082     {
1083       for (c = cmdlist; c; c = c->next)
1084         {
1085           if (c->class == class_user || c->prefixlist != NULL)
1086             show_user_1 (c, "", c->name, gdb_stdout);
1087         }
1088     }
1089 }
1090
1091 /* Search through names of commands and documentations for a certain
1092    regular expression.
1093 */
1094 void
1095 apropos_command (char *searchstr, int from_tty)
1096 {
1097   extern struct cmd_list_element *cmdlist; /*This is the main command list*/
1098   regex_t pattern;
1099   char *pattern_fastmap;
1100   char errorbuffer[512];
1101   pattern_fastmap = xcalloc (256, sizeof (char));
1102   if (searchstr == NULL)
1103       error (_("REGEXP string is empty"));
1104
1105   if (regcomp(&pattern,searchstr,REG_ICASE) == 0)
1106     {
1107       pattern.fastmap=pattern_fastmap;
1108       re_compile_fastmap(&pattern);
1109       apropos_cmd (gdb_stdout,cmdlist,&pattern,"");
1110     }
1111   else
1112     {
1113       regerror(regcomp(&pattern,searchstr,REG_ICASE),NULL,errorbuffer,512);
1114       error (_("Error in regular expression:%s"),errorbuffer);
1115     }
1116   xfree (pattern_fastmap);
1117 }
1118 \f
1119 /* Print a list of files and line numbers which a user may choose from
1120    in order to list a function which was specified ambiguously (as with
1121    `list classname::overloadedfuncname', for example).  The vector in
1122    SALS provides the filenames and line numbers.  */
1123
1124 static void
1125 ambiguous_line_spec (struct symtabs_and_lines *sals)
1126 {
1127   int i;
1128
1129   for (i = 0; i < sals->nelts; ++i)
1130     printf_filtered (_("file: \"%s\", line number: %d\n"),
1131                      sals->sals[i].symtab->filename, sals->sals[i].line);
1132 }
1133
1134 static void
1135 set_debug (char *arg, int from_tty)
1136 {
1137   printf_unfiltered (_("\"set debug\" must be followed by the name of a debug subcommand.\n"));
1138   help_list (setdebuglist, "set debug ", -1, gdb_stdout);
1139 }
1140
1141 static void
1142 show_debug (char *args, int from_tty)
1143 {
1144   cmd_show_list (showdebuglist, from_tty, "");
1145 }
1146
1147 void
1148 init_cmd_lists (void)
1149 {
1150   max_user_call_depth = 1024;
1151
1152   cmdlist = NULL;
1153   infolist = NULL;
1154   enablelist = NULL;
1155   disablelist = NULL;
1156   togglelist = NULL;
1157   stoplist = NULL;
1158   deletelist = NULL;
1159   detachlist = NULL;
1160   enablebreaklist = NULL;
1161   setlist = NULL;
1162   unsetlist = NULL;
1163   showlist = NULL;
1164   sethistlist = NULL;
1165   showhistlist = NULL;
1166   unsethistlist = NULL;
1167   maintenancelist = NULL;
1168   maintenanceinfolist = NULL;
1169   maintenanceprintlist = NULL;
1170   setprintlist = NULL;
1171   showprintlist = NULL;
1172   setchecklist = NULL;
1173   showchecklist = NULL;
1174 }
1175
1176 static void
1177 show_info_verbose (struct ui_file *file, int from_tty,
1178                    struct cmd_list_element *c,
1179                    const char *value)
1180 {
1181   if (info_verbose)
1182     fprintf_filtered (file, _("\
1183 Verbose printing of informational messages is %s.\n"), value);
1184   else
1185     fprintf_filtered (file, _("Verbosity is %s.\n"), value);
1186 }
1187
1188 static void
1189 show_history_expansion_p (struct ui_file *file, int from_tty,
1190                           struct cmd_list_element *c, const char *value)
1191 {
1192   fprintf_filtered (file, _("History expansion on command input is %s.\n"),
1193                     value);
1194 }
1195
1196 static void
1197 show_baud_rate (struct ui_file *file, int from_tty,
1198                 struct cmd_list_element *c, const char *value)
1199 {
1200   fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
1201                     value);
1202 }
1203
1204 static void
1205 show_remote_debug (struct ui_file *file, int from_tty,
1206                    struct cmd_list_element *c, const char *value)
1207 {
1208   fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"),
1209                     value);
1210 }
1211
1212 static void
1213 show_remote_timeout (struct ui_file *file, int from_tty,
1214                      struct cmd_list_element *c, const char *value)
1215 {
1216   fprintf_filtered (file, _("\
1217 Timeout limit to wait for target to respond is %s.\n"),
1218                     value);
1219 }
1220
1221 static void
1222 show_max_user_call_depth (struct ui_file *file, int from_tty,
1223                           struct cmd_list_element *c, const char *value)
1224 {
1225   fprintf_filtered (file, _("\
1226 The max call depth for user-defined commands is %s.\n"),
1227                     value);
1228 }
1229
1230 \f
1231 void
1232 init_cli_cmds (void)
1233 {
1234   struct cmd_list_element *c;
1235   char *source_help_text;
1236
1237   /* Define the classes of commands.
1238      They will appear in the help list in the reverse of this order.  */
1239
1240   add_cmd ("internals", class_maintenance, NULL, _("\
1241 Maintenance commands.\n\
1242 Some gdb commands are provided just for use by gdb maintainers.\n\
1243 These commands are subject to frequent change, and may not be as\n\
1244 well documented as user commands."),
1245            &cmdlist);
1246   add_cmd ("obscure", class_obscure, NULL, _("Obscure features."), &cmdlist);
1247   add_cmd ("aliases", class_alias, NULL, _("Aliases of other commands."), &cmdlist);
1248   add_cmd ("user-defined", class_user, NULL, _("\
1249 User-defined commands.\n\
1250 The commands in this class are those defined by the user.\n\
1251 Use the \"define\" command to define a command."), &cmdlist);
1252   add_cmd ("support", class_support, NULL, _("Support facilities."), &cmdlist);
1253   if (!dbx_commands)
1254     add_cmd ("status", class_info, NULL, _("Status inquiries."), &cmdlist);
1255   add_cmd ("files", class_files, NULL, _("Specifying and examining files."),
1256            &cmdlist);
1257   add_cmd ("breakpoints", class_breakpoint, NULL,
1258            _("Making program stop at certain points."), &cmdlist);
1259   add_cmd ("data", class_vars, NULL, _("Examining data."), &cmdlist);
1260   add_cmd ("stack", class_stack, NULL, _("\
1261 Examining the stack.\n\
1262 The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
1263 counting from zero for the innermost (currently executing) frame.\n\n\
1264 At any time gdb identifies one frame as the \"selected\" frame.\n\
1265 Variable lookups are done with respect to the selected frame.\n\
1266 When the program being debugged stops, gdb selects the innermost frame.\n\
1267 The commands below can be used to select other frames by number or address."),
1268            &cmdlist);
1269   add_cmd ("running", class_run, NULL, _("Running the program."), &cmdlist);
1270
1271   /* Define general commands. */
1272
1273   add_com ("pwd", class_files, pwd_command, _("\
1274 Print working directory.  This is used for your program as well."));
1275
1276   c = add_cmd ("cd", class_files, cd_command, _("\
1277 Set working directory to DIR for debugger and program being debugged.\n\
1278 The change does not take effect for the program being debugged\n\
1279 until the next time it is started."), &cmdlist);
1280   set_cmd_completer (c, filename_completer);
1281
1282   add_com ("echo", class_support, echo_command, _("\
1283 Print a constant string.  Give string as argument.\n\
1284 C escape sequences may be used in the argument.\n\
1285 No newline is added at the end of the argument;\n\
1286 use \"\\n\" if you want a newline to be printed.\n\
1287 Since leading and trailing whitespace are ignored in command arguments,\n\
1288 if you want to print some you must use \"\\\" before leading whitespace\n\
1289 to be printed or after trailing whitespace."));
1290   add_com ("document", class_support, document_command, _("\
1291 Document a user-defined command.\n\
1292 Give command name as argument.  Give documentation on following lines.\n\
1293 End with a line of just \"end\"."));
1294   add_com ("define", class_support, define_command, _("\
1295 Define a new command name.  Command name is argument.\n\
1296 Definition appears on following lines, one command per line.\n\
1297 End with a line of just \"end\".\n\
1298 Use the \"document\" command to give documentation for the new command.\n\
1299 Commands defined in this way may have up to ten arguments."));
1300
1301   source_help_text = xstrprintf (_("\
1302 Read commands from a file named FILE.\n\
1303 Optional -v switch (before the filename) causes each command in\n\
1304 FILE to be echoed as it is executed.\n\
1305 Note that the file \"%s\" is read automatically in this way\n\
1306 when GDB is started."), gdbinit);
1307   c = add_cmd ("source", class_support, source_command,
1308                source_help_text, &cmdlist);
1309   set_cmd_completer (c, filename_completer);
1310
1311   add_com ("quit", class_support, quit_command, _("Exit gdb."));
1312   c = add_com ("help", class_support, help_command,
1313                _("Print list of commands."));
1314   set_cmd_completer (c, command_completer);
1315   add_com_alias ("q", "quit", class_support, 1);
1316   add_com_alias ("h", "help", class_support, 1);
1317
1318   add_setshow_boolean_cmd ("verbose", class_support, &info_verbose, _("\
1319 Set verbosity."), _("\
1320 Show verbosity."), NULL,
1321                            set_verbose,
1322                            show_info_verbose,
1323                            &setlist, &showlist);
1324
1325   add_prefix_cmd ("history", class_support, set_history,
1326                   _("Generic command for setting command history parameters."),
1327                   &sethistlist, "set history ", 0, &setlist);
1328   add_prefix_cmd ("history", class_support, show_history,
1329                   _("Generic command for showing command history parameters."),
1330                   &showhistlist, "show history ", 0, &showlist);
1331
1332   add_setshow_boolean_cmd ("expansion", no_class, &history_expansion_p, _("\
1333 Set history expansion on command input."), _("\
1334 Show history expansion on command input."), _("\
1335 Without an argument, history expansion is enabled."),
1336                            NULL,
1337                            show_history_expansion_p,
1338                            &sethistlist, &showhistlist);
1339
1340   add_prefix_cmd ("info", class_info, info_command, _("\
1341 Generic command for showing things about the program being debugged."),
1342                   &infolist, "info ", 0, &cmdlist);
1343   add_com_alias ("i", "info", class_info, 1);
1344   add_com_alias ("inf", "info", class_info, 1);
1345
1346   add_com ("complete", class_obscure, complete_command,
1347            _("List the completions for the rest of the line as a command."));
1348
1349   add_prefix_cmd ("show", class_info, show_command, _("\
1350 Generic command for showing things about the debugger."),
1351                   &showlist, "show ", 0, &cmdlist);
1352   /* Another way to get at the same thing.  */
1353   add_info ("set", show_command, _("Show all GDB settings."));
1354
1355   add_cmd ("commands", no_class, show_commands, _("\
1356 Show the history of commands you typed.\n\
1357 You can supply a command number to start with, or a `+' to start after\n\
1358 the previous command number shown."),
1359            &showlist);
1360
1361   add_cmd ("version", no_class, show_version,
1362            _("Show what version of GDB this is."), &showlist);
1363
1364   add_com ("while", class_support, while_command, _("\
1365 Execute nested commands WHILE the conditional expression is non zero.\n\
1366 The conditional expression must follow the word `while' and must in turn be\n\
1367 followed by a new line.  The nested commands must be entered one per line,\n\
1368 and should be terminated by the word `end'."));
1369
1370   add_com ("if", class_support, if_command, _("\
1371 Execute nested commands once IF the conditional expression is non zero.\n\
1372 The conditional expression must follow the word `if' and must in turn be\n\
1373 followed by a new line.  The nested commands must be entered one per line,\n\
1374 and should be terminated by the word 'else' or `end'.  If an else clause\n\
1375 is used, the same rules apply to its nested commands as to the first ones."));
1376
1377   /* If target is open when baud changes, it doesn't take effect until the
1378      next open (I think, not sure).  */
1379   add_setshow_zinteger_cmd ("remotebaud", no_class, &baud_rate, _("\
1380 Set baud rate for remote serial I/O."), _("\
1381 Show baud rate for remote serial I/O."), _("\
1382 This value is used to set the speed of the serial port when debugging\n\
1383 using remote targets."),
1384                             NULL,
1385                             show_baud_rate,
1386                             &setlist, &showlist);
1387
1388   add_setshow_zinteger_cmd ("remote", no_class, &remote_debug, _("\
1389 Set debugging of remote protocol."), _("\
1390 Show debugging of remote protocol."), _("\
1391 When enabled, each packet sent or received with the remote target\n\
1392 is displayed."),
1393                             NULL,
1394                             show_remote_debug,
1395                             &setdebuglist, &showdebuglist);
1396
1397   add_setshow_integer_cmd ("remotetimeout", no_class, &remote_timeout, _("\
1398 Set timeout limit to wait for target to respond."), _("\
1399 Show timeout limit to wait for target to respond."), _("\
1400 This value is used to set the time limit for gdb to wait for a response\n\
1401 from the target."),
1402                            NULL,
1403                            show_remote_timeout,
1404                            &setlist, &showlist);
1405
1406   add_prefix_cmd ("debug", no_class, set_debug,
1407                   _("Generic command for setting gdb debugging flags"),
1408                   &setdebuglist, "set debug ", 0, &setlist);
1409
1410   add_prefix_cmd ("debug", no_class, show_debug,
1411                   _("Generic command for showing gdb debugging flags"),
1412                   &showdebuglist, "show debug ", 0, &showlist);
1413
1414   c = add_com ("shell", class_support, shell_escape, _("\
1415 Execute the rest of the line as a shell command.\n\
1416 With no arguments, run an inferior shell."));
1417   set_cmd_completer (c, filename_completer);
1418
1419   c = add_com ("edit", class_files, edit_command, _("\
1420 Edit specified file or function.\n\
1421 With no argument, edits file containing most recent line listed.\n\
1422 Editing targets can be specified in these ways:\n\
1423   FILE:LINENUM, to edit at that line in that file,\n\
1424   FUNCTION, to edit at the beginning of that function,\n\
1425   FILE:FUNCTION, to distinguish among like-named static functions.\n\
1426   *ADDRESS, to edit at the line containing that address.\n\
1427 Uses EDITOR environment variable contents as editor (or ex as default)."));
1428
1429   c->completer = location_completer;
1430
1431   add_com ("list", class_files, list_command, _("\
1432 List specified function or line.\n\
1433 With no argument, lists ten more lines after or around previous listing.\n\
1434 \"list -\" lists the ten lines before a previous ten-line listing.\n\
1435 One argument specifies a line, and ten lines are listed around that line.\n\
1436 Two arguments with comma between specify starting and ending lines to list.\n\
1437 Lines can be specified in these ways:\n\
1438   LINENUM, to list around that line in current file,\n\
1439   FILE:LINENUM, to list around that line in that file,\n\
1440   FUNCTION, to list around beginning of that function,\n\
1441   FILE:FUNCTION, to distinguish among like-named static functions.\n\
1442   *ADDRESS, to list around the line containing that address.\n\
1443 With two args if one is empty it stands for ten lines away from the other arg."));
1444
1445   if (!xdb_commands)
1446     add_com_alias ("l", "list", class_files, 1);
1447   else
1448     add_com_alias ("v", "list", class_files, 1);
1449
1450   if (dbx_commands)
1451     add_com_alias ("file", "list", class_files, 1);
1452
1453   c = add_com ("disassemble", class_vars, disassemble_command, _("\
1454 Disassemble a specified section of memory.\n\
1455 Default is the function surrounding the pc of the selected frame.\n\
1456 With a /m modifier, source lines are included (if available).\n\
1457 With a single argument, the function surrounding that address is dumped.\n\
1458 Two arguments are taken as a range of memory to dump."));
1459   set_cmd_completer (c, location_completer);
1460   if (xdb_commands)
1461     add_com_alias ("va", "disassemble", class_xdb, 0);
1462
1463   /* NOTE: cagney/2000-03-20: Being able to enter ``(gdb) !ls'' would
1464      be a really useful feature.  Unfortunately, the below wont do
1465      this.  Instead it adds support for the form ``(gdb) ! ls''
1466      (i.e. the space is required).  If the ``!'' command below is
1467      added the complains about no ``!'' command would be replaced by
1468      complains about how the ``!'' command is broken :-) */
1469   if (xdb_commands)
1470     add_com_alias ("!", "shell", class_support, 0);
1471
1472   c = add_com ("make", class_support, make_command, _("\
1473 Run the ``make'' program using the rest of the line as arguments."));
1474   set_cmd_completer (c, filename_completer);
1475   add_cmd ("user", no_class, show_user, _("\
1476 Show definitions of user defined commands.\n\
1477 Argument is the name of the user defined command.\n\
1478 With no argument, show definitions of all user defined commands."), &showlist);
1479   add_com ("apropos", class_support, apropos_command,
1480            _("Search for commands matching a REGEXP"));
1481
1482   add_setshow_integer_cmd ("max-user-call-depth", no_class,
1483                            &max_user_call_depth, _("\
1484 Set the max call depth for user-defined commands."), _("\
1485 Show the max call depth for user-defined commands."), NULL,
1486                            NULL,
1487                            show_max_user_call_depth,
1488                            &setlist, &showlist);
1489
1490   add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\
1491 Set tracing of GDB CLI commands."), _("\
1492 Show state of GDB CLI command tracing."), _("\
1493 When 'on', each command is displayed as it is executed."),
1494                            NULL,
1495                            NULL,
1496                            &setlist, &showlist);
1497 }