contrib/gdb-6/gdb/cli/cli-cmds.c

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