gdb/cli/cli-cmds.c

   1 /* GDB CLI commands.
   2
   3    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
   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 2 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, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "defs.h"
  24 #include "readline/readline.h"
  25 #include "readline/tilde.h"
  26 #include "completer.h"
  27 #include "target.h"      /* For baud_rate, remote_debug and remote_timeout */
  28 #include "gdb_wait.h"           /* For shell escape implementation */
  29 #include "gdb_regex.h"          /* Used by apropos_command */
  30 #include "gdb_string.h"
  31 #include "gdb_vfork.h"
  32 #include "linespec.h"
  33 #include "expression.h"
  34 #include "frame.h"
  35 #include "value.h"
  36 #include "language.h"
  37 #include "filenames.h"          /* for DOSish file names */
  38 #include "objfiles.h"
  39 #include "source.h"
  40 #include "disasm.h"
  41
  42 #include "ui-out.h"
  43
  44 #include "top.h"
  45 #include "cli/cli-decode.h"
  46 #include "cli/cli-script.h"
  47 #include "cli/cli-setshow.h"
  48 #include "cli/cli-cmds.h"
  49
  50 #ifdef TUI
  51 #include "tui/tui.h"            /* For tui_active et.al.   */
  52 #endif
  53
  54 #include <fcntl.h>
  55
  56 /* Prototypes for local command functions */
  57
  58 static void complete_command (char *, int);
  59
  60 static void echo_command (char *, int);
  61
  62 static void pwd_command (char *, int);
  63
  64 static void show_version (char *, int);
  65
  66 static void help_command (char *, int);
  67
  68 static void show_command (char *, int);
  69
  70 static void info_command (char *, int);
  71
  72 static void show_debug (char *, int);
  73
  74 static void set_debug (char *, int);
  75
  76 static void show_user (char *, int);
  77
  78 static void make_command (char *, int);
  79
  80 static void shell_escape (char *, int);
  81
  82 static void edit_command (char *, int);
  83
  84 static void list_command (char *, int);
  85
  86 void apropos_command (char *, int);
  87
  88 /* Prototypes for local utility functions */
  89
  90 static void ambiguous_line_spec (struct symtabs_and_lines *);
  91 \f
  92 /* Limit the call depth of user-defined commands */
  93 int max_user_call_depth;
  94
  95 /* Define all cmd_list_elements.  */
  96
  97 /* Chain containing all defined commands.  */
  98
  99 struct cmd_list_element *cmdlist;
 100
 101 /* Chain containing all defined info subcommands.  */
 102
 103 struct cmd_list_element *infolist;
 104
 105 /* Chain containing all defined enable subcommands. */
 106
 107 struct cmd_list_element *enablelist;
 108
 109 /* Chain containing all defined disable subcommands. */
 110
 111 struct cmd_list_element *disablelist;
 112
 113 /* Chain containing all defined toggle subcommands. */
 114
 115 struct cmd_list_element *togglelist;
 116
 117 /* Chain containing all defined stop subcommands. */
 118
 119 struct cmd_list_element *stoplist;
 120
 121 /* Chain containing all defined delete subcommands. */
 122
 123 struct cmd_list_element *deletelist;
 124
 125 /* Chain containing all defined "enable breakpoint" subcommands. */
 126
 127 struct cmd_list_element *enablebreaklist;
 128
 129 /* Chain containing all defined set subcommands */
 130
 131 struct cmd_list_element *setlist;
 132
 133 /* Chain containing all defined unset subcommands */
 134
 135 struct cmd_list_element *unsetlist;
 136
 137 /* Chain containing all defined show subcommands.  */
 138
 139 struct cmd_list_element *showlist;
 140
 141 /* Chain containing all defined \"set history\".  */
 142
 143 struct cmd_list_element *sethistlist;
 144
 145 /* Chain containing all defined \"show history\".  */
 146
 147 struct cmd_list_element *showhistlist;
 148
 149 /* Chain containing all defined \"unset history\".  */
 150
 151 struct cmd_list_element *unsethistlist;
 152
 153 /* Chain containing all defined maintenance subcommands. */
 154
 155 struct cmd_list_element *maintenancelist;
 156
 157 /* Chain containing all defined "maintenance info" subcommands. */
 158
 159 struct cmd_list_element *maintenanceinfolist;
 160
 161 /* Chain containing all defined "maintenance print" subcommands. */
 162
 163 struct cmd_list_element *maintenanceprintlist;
 164
 165 struct cmd_list_element *setprintlist;
 166
 167 struct cmd_list_element *showprintlist;
 168
 169 struct cmd_list_element *setdebuglist;
 170
 171 struct cmd_list_element *showdebuglist;
 172
 173 struct cmd_list_element *setchecklist;
 174
 175 struct cmd_list_element *showchecklist;
 176
 177 /* Command tracing state.  */
 178
 179 int source_verbose = 0;
 180 int trace_commands = 0;
 181 \f
 182 /* Utility used everywhere when at least one argument is needed and
 183    none is supplied. */
 184
 185 void
 186 error_no_arg (char *why)
 187 {
 188   error (_("Argument required (%s)."), why);
 189 }
 190
 191 /* The "info" command is defined as a prefix, with allow_unknown = 0.
 192    Therefore, its own definition is called only for "info" with no args.  */
 193
 194 static void
 195 info_command (char *arg, int from_tty)
 196 {
 197   printf_unfiltered (_("\"info\" must be followed by the name of an info command.\n"));
 198   help_list (infolist, "info ", -1, gdb_stdout);
 199 }
 200
 201 /* The "show" command with no arguments shows all the settings.  */
 202
 203 static void
 204 show_command (char *arg, int from_tty)
 205 {
 206   cmd_show_list (showlist, from_tty, "");
 207 }
 208 \f
 209 /* Provide documentation on command or list given by COMMAND.  FROM_TTY
 210    is ignored.  */
 211
 212 static void
 213 help_command (char *command, int from_tty)
 214 {
 215   help_cmd (command, gdb_stdout);
 216 }
 217 \f
 218 /* String compare function for qsort.  */
 219 static int
 220 compare_strings (const void *arg1, const void *arg2)
 221 {
 222   const char **s1 = (const char **) arg1;
 223   const char **s2 = (const char **) arg2;
 224   return strcmp (*s1, *s2);
 225 }
 226
 227 /* The "complete" command is used by Emacs to implement completion.  */
 228
 229 static void
 230 complete_command (char *arg, int from_tty)
 231 {
 232   int i;
 233   int argpoint;
 234   char **completions, *point, *arg_prefix;
 235
 236   dont_repeat ();
 237
 238   if (arg == NULL)
 239     arg = "";
 240   argpoint = strlen (arg);
 241
 242   /* complete_line assumes that its first argument is somewhere within,
 243      and except for filenames at the beginning of, the word to be completed.
 244      The following crude imitation of readline's word-breaking tries to
 245      accomodate this.  */
 246   point = arg + argpoint;
 247   while (point > arg)
 248     {
 249       if (strchr (rl_completer_word_break_characters, point[-1]) != 0)
 250         break;
 251       point--;
 252     }
 253
 254   arg_prefix = alloca (point - arg + 1);
 255   memcpy (arg_prefix, arg, point - arg);
 256   arg_prefix[point - arg] = 0;
 257
 258   completions = complete_line (point, arg, argpoint);
 259
 260   if (completions)
 261     {
 262       int item, size;
 263
 264       for (size = 0; completions[size]; ++size)
 265         ;
 266       qsort (completions, size, sizeof (char *), compare_strings);
 267
 268       /* We do extra processing here since we only want to print each
 269          unique item once.  */
 270       item = 0;
 271       while (item < size)
 272         {
 273           int next_item;
 274           printf_unfiltered ("%s%s\n", arg_prefix, completions[item]);
 275           next_item = item + 1;
 276           while (next_item < size
 277                  && ! strcmp (completions[item], completions[next_item]))
 278             {
 279               xfree (completions[next_item]);
 280               ++next_item;
 281             }
 282
 283           xfree (completions[item]);
 284           item = next_item;
 285         }
 286
 287       xfree (completions);
 288     }
 289 }
 290
 291 int
 292 is_complete_command (struct cmd_list_element *c)
 293 {
 294   return cmd_cfunc_eq (c, complete_command);
 295 }
 296
 297 static void
 298 show_version (char *args, int from_tty)
 299 {
 300   immediate_quit++;
 301   print_gdb_version (gdb_stdout);
 302   printf_filtered ("\n");
 303   immediate_quit--;
 304 }
 305
 306 /* Handle the quit command.  */
 307
 308 void
 309 quit_command (char *args, int from_tty)
 310 {
 311   if (!quit_confirm ())
 312     error (_("Not confirmed."));
 313   quit_force (args, from_tty);
 314 }
 315
 316 static void
 317 pwd_command (char *args, int from_tty)
 318 {
 319   if (args)
 320     error (_("The \"pwd\" command does not take an argument: %s"), args);
 321   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 322
 323   if (strcmp (gdb_dirbuf, current_directory) != 0)
 324     printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
 325                        current_directory, gdb_dirbuf);
 326   else
 327     printf_unfiltered (_("Working directory %s.\n"), current_directory);
 328 }
 329
 330 void
 331 cd_command (char *dir, int from_tty)
 332 {
 333   int len;
 334   /* Found something other than leading repetitions of "/..".  */
 335   int found_real_path;
 336   char *p;
 337
 338   /* If the new directory is absolute, repeat is a no-op; if relative,
 339      repeat might be useful but is more likely to be a mistake.  */
 340   dont_repeat ();
 341
 342   if (dir == 0)
 343     error_no_arg (_("new working directory"));
 344
 345   dir = tilde_expand (dir);
 346   make_cleanup (xfree, dir);
 347
 348   if (chdir (dir) < 0)
 349     perror_with_name (dir);
 350
 351 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 352   /* There's too much mess with DOSish names like "d:", "d:.",
 353      "d:./foo" etc.  Instead of having lots of special #ifdef'ed code,
 354      simply get the canonicalized name of the current directory.  */
 355   dir = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 356 #endif
 357
 358   len = strlen (dir);
 359   if (IS_DIR_SEPARATOR (dir[len - 1]))
 360     {
 361       /* Remove the trailing slash unless this is a root directory
 362          (including a drive letter on non-Unix systems).  */
 363       if (!(len == 1)           /* "/" */
 364 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 365           && !(len == 3 && dir[1] == ':') /* "d:/" */
 366 #endif
 367           )
 368         len--;
 369     }
 370
 371   dir = savestring (dir, len);
 372   if (IS_ABSOLUTE_PATH (dir))
 373     current_directory = dir;
 374   else
 375     {
 376       if (IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1]))
 377         current_directory = concat (current_directory, dir, (char *)NULL);
 378       else
 379         current_directory = concat (current_directory, SLASH_STRING,
 380                                     dir, (char *)NULL);
 381       xfree (dir);
 382     }
 383
 384   /* Now simplify any occurrences of `.' and `..' in the pathname.  */
 385
 386   found_real_path = 0;
 387   for (p = current_directory; *p;)
 388     {
 389       if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.'
 390           && (p[2] == 0 || IS_DIR_SEPARATOR (p[2])))
 391         strcpy (p, p + 2);
 392       else if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' && p[2] == '.'
 393                && (p[3] == 0 || IS_DIR_SEPARATOR (p[3])))
 394         {
 395           if (found_real_path)
 396             {
 397               /* Search backwards for the directory just before the "/.."
 398                  and obliterate it and the "/..".  */
 399               char *q = p;
 400               while (q != current_directory && !IS_DIR_SEPARATOR (q[-1]))
 401                 --q;
 402
 403               if (q == current_directory)
 404                 /* current_directory is
 405                    a relative pathname ("can't happen"--leave it alone).  */
 406                 ++p;
 407               else
 408                 {
 409                   strcpy (q - 1, p + 3);
 410                   p = q - 1;
 411                 }
 412             }
 413           else
 414             /* We are dealing with leading repetitions of "/..", for example
 415                "/../..", which is the Mach super-root.  */
 416             p += 3;
 417         }
 418       else
 419         {
 420           found_real_path = 1;
 421           ++p;
 422         }
 423     }
 424
 425   forget_cached_source_info ();
 426
 427   if (from_tty)
 428     pwd_command ((char *) 0, 1);
 429 }
 430 \f
 431 void
 432 source_script (char *file, int from_tty)
 433 {
 434   FILE *stream;
 435   struct cleanup *old_cleanups;
 436   char *full_pathname = NULL;
 437   int fd;
 438
 439   if (file == NULL || *file == 0)
 440     {
 441       error (_("source command requires file name of file to source."));
 442     }
 443
 444   file = tilde_expand (file);
 445   old_cleanups = make_cleanup (xfree, file);
 446
 447   /* Search for and open 'file' on the search path used for source
 448      files.  Put the full location in 'full_pathname'.  */
 449   fd = openp (source_path, OPF_TRY_CWD_FIRST,
 450               file, O_RDONLY, 0, &full_pathname);
 451
 452   /* Use the full path name, if it is found.  */
 453   if (full_pathname != NULL && fd != -1)
 454     {
 455       file = full_pathname;
 456     }
 457
 458   if (fd == -1)
 459     {
 460       if (from_tty)
 461         perror_with_name (file);
 462       else
 463         return;
 464     }
 465
 466   stream = fdopen (fd, FOPEN_RT);
 467   script_from_file (stream, file);
 468
 469   do_cleanups (old_cleanups);
 470 }
 471
 472 /* Return the source_verbose global variable to its previous state
 473    on exit from the source command, by whatever means.  */
 474 static void
 475 source_verbose_cleanup (void *old_value)
 476 {
 477   source_verbose = *(int *)old_value;
 478   xfree (old_value);
 479 }
 480
 481 static void
 482 source_command (char *args, int from_tty)
 483 {
 484   struct cleanup *old_cleanups;
 485   char *file = args;
 486   int *old_source_verbose = xmalloc (sizeof(int));
 487
 488   *old_source_verbose = source_verbose;
 489   old_cleanups = make_cleanup (source_verbose_cleanup, old_source_verbose);
 490
 491   /* -v causes the source command to run in verbose mode.
 492      We still have to be able to handle filenames with spaces in a
 493      backward compatible way, so buildargv is not appropriate.  */
 494
 495   if (args)
 496     {
 497       /* Make sure leading white space does not break the comparisons.  */
 498       while (isspace(args[0]))
 499         args++;
 500
 501       /* Is -v the first thing in the string?  */
 502       if (args[0] == '-' && args[1] == 'v' && isspace (args[2]))
 503         {
 504           source_verbose = 1;
 505
 506           /* Trim -v and whitespace from the filename.  */
 507           file = &args[3];
 508           while (isspace (file[0]))
 509             file++;
 510         }
 511     }
 512
 513   return source_script (file, from_tty);
 514 }
 515
 516
 517 static void
 518 echo_command (char *text, int from_tty)
 519 {
 520   char *p = text;
 521   int c;
 522
 523   if (text)
 524     while ((c = *p++) != '\0')
 525       {
 526         if (c == '\\')
 527           {
 528             /* \ at end of argument is used after spaces
 529                so they won't be lost.  */
 530             if (*p == 0)
 531               return;
 532
 533             c = parse_escape (&p);
 534             if (c >= 0)
 535               printf_filtered ("%c", c);
 536           }
 537         else
 538           printf_filtered ("%c", c);
 539       }
 540
 541   /* Force this output to appear now.  */
 542   wrap_here ("");
 543   gdb_flush (gdb_stdout);
 544 }
 545
 546 static void
 547 shell_escape (char *arg, int from_tty)
 548 {
 549 #if defined(CANT_FORK) || \
 550       (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
 551   /* If ARG is NULL, they want an inferior shell, but `system' just
 552      reports if the shell is available when passed a NULL arg.  */
 553   int rc = system (arg ? arg : "");
 554
 555   if (!arg)
 556     arg = "inferior shell";
 557
 558   if (rc == -1)
 559     {
 560       fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg,
 561                           safe_strerror (errno));
 562       gdb_flush (gdb_stderr);
 563     }
 564   else if (rc)
 565     {
 566       fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc);
 567       gdb_flush (gdb_stderr);
 568     }
 569 #ifdef GLOBAL_CURDIR
 570   /* Make sure to return to the directory GDB thinks it is, in case the
 571      shell command we just ran changed it.  */
 572   chdir (current_directory);
 573 #endif
 574 #else /* Can fork.  */
 575   int rc, status, pid;
 576
 577   if ((pid = vfork ()) == 0)
 578     {
 579       char *p, *user_shell;
 580
 581       if ((user_shell = (char *) getenv ("SHELL")) == NULL)
 582         user_shell = "/bin/sh";
 583
 584       /* Get the name of the shell for arg0 */
 585       if ((p = strrchr (user_shell, '/')) == NULL)
 586         p = user_shell;
 587       else
 588         p++;                    /* Get past '/' */
 589
 590       if (!arg)
 591         execl (user_shell, p, (char *) 0);
 592       else
 593         execl (user_shell, p, "-c", arg, (char *) 0);
 594
 595       fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
 596                           safe_strerror (errno));
 597       gdb_flush (gdb_stderr);
 598       _exit (0177);
 599     }
 600
 601   if (pid != -1)
 602     while ((rc = wait (&status)) != pid && rc != -1)
 603       ;
 604   else
 605     error (_("Fork failed"));
 606 #endif /* Can fork.  */
 607 }
 608
 609 static void
 610 edit_command (char *arg, int from_tty)
 611 {
 612   struct symtabs_and_lines sals;
 613   struct symtab_and_line sal;
 614   struct symbol *sym;
 615   char *arg1;
 616   int cmdlen, log10;
 617   unsigned m;
 618   char *editor;
 619   char *p, *fn;
 620
 621   /* Pull in the current default source line if necessary */
 622   if (arg == 0)
 623     {
 624       set_default_source_symtab_and_line ();
 625       sal = get_current_source_symtab_and_line ();
 626     }
 627
 628   /* bare "edit" edits file with present line.  */
 629
 630   if (arg == 0)
 631     {
 632       if (sal.symtab == 0)
 633         error (_("No default source file yet."));
 634       sal.line += get_lines_to_list () / 2;
 635     }
 636   else
 637     {
 638
 639       /* Now should only be one argument -- decode it in SAL */
 640
 641       arg1 = arg;
 642       sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
 643
 644       if (! sals.nelts) return;  /*  C++  */
 645       if (sals.nelts > 1) {
 646         ambiguous_line_spec (&sals);
 647         xfree (sals.sals);
 648         return;
 649       }
 650
 651       sal = sals.sals[0];
 652       xfree (sals.sals);
 653
 654       if (*arg1)
 655         error (_("Junk at end of line specification."));
 656
 657       /* if line was specified by address,
 658          first print exactly which line, and which file.
 659          In this case, sal.symtab == 0 means address is outside
 660          of all known source files, not that user failed to give a filename.  */
 661       if (*arg == '*')
 662         {
 663           if (sal.symtab == 0)
 664             /* FIXME-32x64--assumes sal.pc fits in long.  */
 665             error (_("No source file for address %s."),
 666                    hex_string ((unsigned long) sal.pc));
 667           sym = find_pc_function (sal.pc);
 668           if (sym)
 669             {
 670               deprecated_print_address_numeric (sal.pc, 1, gdb_stdout);
 671               printf_filtered (" is in ");
 672               fputs_filtered (SYMBOL_PRINT_NAME (sym), gdb_stdout);
 673               printf_filtered (" (%s:%d).\n", sal.symtab->filename, sal.line);
 674             }
 675           else
 676             {
 677               deprecated_print_address_numeric (sal.pc, 1, gdb_stdout);
 678               printf_filtered (" is at %s:%d.\n",
 679                                sal.symtab->filename, sal.line);
 680             }
 681         }
 682
 683       /* If what was given does not imply a symtab, it must be an undebuggable
 684          symbol which means no source code.  */
 685
 686       if (sal.symtab == 0)
 687         error (_("No line number known for %s."), arg);
 688     }
 689
 690   if ((editor = (char *) getenv ("EDITOR")) == NULL)
 691       editor = "/bin/ex";
 692
 693   /* Approximate base-10 log of line to 1 unit for digit count */
 694   for(log10=32, m=0x80000000; !(sal.line & m) && log10>0; log10--, m=m>>1);
 695   log10 = 1 + (int)((log10 + (0 == ((m-1) & sal.line)))/3.32192809);
 696
 697   /* If we don't already know the full absolute file name of the
 698      source file, find it now.  */
 699   if (!sal.symtab->fullname)
 700     {
 701       fn = symtab_to_fullname (sal.symtab);
 702       if (!fn)
 703         fn = "unknown";
 704     }
 705   else
 706     fn = sal.symtab->fullname;
 707
 708   /* Quote the file name, in case it has whitespace or other special
 709      characters.  */
 710   p = xstrprintf ("%s +%d \"%s\"", editor, sal.line, fn);
 711   shell_escape(p, from_tty);
 712   xfree(p);
 713 }
 714
 715 static void
 716 list_command (char *arg, int from_tty)
 717 {
 718   struct symtabs_and_lines sals, sals_end;
 719   struct symtab_and_line sal = { 0 };
 720   struct symtab_and_line sal_end = { 0 };
 721   struct symtab_and_line cursal = { 0 };
 722   struct symbol *sym;
 723   char *arg1;
 724   int no_end = 1;
 725   int dummy_end = 0;
 726   int dummy_beg = 0;
 727   int linenum_beg = 0;
 728   char *p;
 729
 730   /* Pull in the current default source line if necessary */
 731   if (arg == 0 || arg[0] == '+' || arg[0] == '-')
 732     {
 733       set_default_source_symtab_and_line ();
 734       cursal = get_current_source_symtab_and_line ();
 735     }
 736
 737   /* "l" or "l +" lists next ten lines.  */
 738
 739   if (arg == 0 || strcmp (arg, "+") == 0)
 740     {
 741       print_source_lines (cursal.symtab, cursal.line,
 742                           cursal.line + get_lines_to_list (), 0);
 743       return;
 744     }
 745
 746   /* "l -" lists previous ten lines, the ones before the ten just listed.  */
 747   if (strcmp (arg, "-") == 0)
 748     {
 749       print_source_lines (cursal.symtab,
 750                           max (get_first_line_listed () - get_lines_to_list (), 1),
 751                           get_first_line_listed (), 0);
 752       return;
 753     }
 754
 755   /* Now if there is only one argument, decode it in SAL
 756      and set NO_END.
 757      If there are two arguments, decode them in SAL and SAL_END
 758      and clear NO_END; however, if one of the arguments is blank,
 759      set DUMMY_BEG or DUMMY_END to record that fact.  */
 760
 761   if (!have_full_symbols () && !have_partial_symbols ())
 762     error (_("No symbol table is loaded.  Use the \"file\" command."));
 763
 764   arg1 = arg;
 765   if (*arg1 == ',')
 766     dummy_beg = 1;
 767   else
 768     {
 769       sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
 770
 771       if (!sals.nelts)
 772         return;                 /*  C++  */
 773       if (sals.nelts > 1)
 774         {
 775           ambiguous_line_spec (&sals);
 776           xfree (sals.sals);
 777           return;
 778         }
 779
 780       sal = sals.sals[0];
 781       xfree (sals.sals);
 782     }
 783
 784   /* Record whether the BEG arg is all digits.  */
 785
 786   for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
 787   linenum_beg = (p == arg1);
 788
 789   while (*arg1 == ' ' || *arg1 == '\t')
 790     arg1++;
 791   if (*arg1 == ',')
 792     {
 793       no_end = 0;
 794       arg1++;
 795       while (*arg1 == ' ' || *arg1 == '\t')
 796         arg1++;
 797       if (*arg1 == 0)
 798         dummy_end = 1;
 799       else
 800         {
 801           if (dummy_beg)
 802             sals_end = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
 803           else
 804             sals_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line, 0, 0);
 805           if (sals_end.nelts == 0)
 806             return;
 807           if (sals_end.nelts > 1)
 808             {
 809               ambiguous_line_spec (&sals_end);
 810               xfree (sals_end.sals);
 811               return;
 812             }
 813           sal_end = sals_end.sals[0];
 814           xfree (sals_end.sals);
 815         }
 816     }
 817
 818   if (*arg1)
 819     error (_("Junk at end of line specification."));
 820
 821   if (!no_end && !dummy_beg && !dummy_end
 822       && sal.symtab != sal_end.symtab)
 823     error (_("Specified start and end are in different files."));
 824   if (dummy_beg && dummy_end)
 825     error (_("Two empty args do not say what lines to list."));
 826
 827   /* if line was specified by address,
 828      first print exactly which line, and which file.
 829      In this case, sal.symtab == 0 means address is outside
 830      of all known source files, not that user failed to give a filename.  */
 831   if (*arg == '*')
 832     {
 833       if (sal.symtab == 0)
 834         /* FIXME-32x64--assumes sal.pc fits in long.  */
 835         error (_("No source file for address %s."),
 836                hex_string ((unsigned long) sal.pc));
 837       sym = find_pc_function (sal.pc);
 838       if (sym)
 839         {
 840           deprecated_print_address_numeric (sal.pc, 1, gdb_stdout);
 841           printf_filtered (" is in ");
 842           fputs_filtered (SYMBOL_PRINT_NAME (sym), gdb_stdout);
 843           printf_filtered (" (%s:%d).\n", sal.symtab->filename, sal.line);
 844         }
 845       else
 846         {
 847           deprecated_print_address_numeric (sal.pc, 1, gdb_stdout);
 848           printf_filtered (" is at %s:%d.\n",
 849                            sal.symtab->filename, sal.line);
 850         }
 851     }
 852
 853   /* If line was not specified by just a line number,
 854      and it does not imply a symtab, it must be an undebuggable symbol
 855      which means no source code.  */
 856
 857   if (!linenum_beg && sal.symtab == 0)
 858     error (_("No line number known for %s."), arg);
 859
 860   /* If this command is repeated with RET,
 861      turn it into the no-arg variant.  */
 862
 863   if (from_tty)
 864     *arg = 0;
 865
 866   if (dummy_beg && sal_end.symtab == 0)
 867     error (_("No default source file yet.  Do \"help list\"."));
 868   if (dummy_beg)
 869     print_source_lines (sal_end.symtab,
 870                         max (sal_end.line - (get_lines_to_list () - 1), 1),
 871                         sal_end.line + 1, 0);
 872   else if (sal.symtab == 0)
 873     error (_("No default source file yet.  Do \"help list\"."));
 874   else if (no_end)
 875     {
 876       int first_line = sal.line - get_lines_to_list () / 2;
 877
 878       if (first_line < 1) first_line = 1;
 879
 880       print_source_lines (sal.symtab,
 881                           first_line,
 882                           first_line + get_lines_to_list (),
 883                           0);
 884     }
 885   else
 886     print_source_lines (sal.symtab, sal.line,
 887                         (dummy_end
 888                          ? sal.line + get_lines_to_list ()
 889                          : sal_end.line + 1),
 890                         0);
 891 }
 892
 893 /* Dump a specified section of assembly code.  With no command line
 894    arguments, this command will dump the assembly code for the
 895    function surrounding the pc value in the selected frame.  With one
 896    argument, it will dump the assembly code surrounding that pc value.
 897    Two arguments are interpeted as bounds within which to dump
 898    assembly.  */
 899
 900 static void
 901 disassemble_command (char *arg, int from_tty)
 902 {
 903   CORE_ADDR low, high;
 904   char *name;
 905   CORE_ADDR pc, pc_masked;
 906   char *space_index;
 907 #if 0
 908   asection *section;
 909 #endif
 910
 911   name = NULL;
 912   if (!arg)
 913     {
 914       if (!deprecated_selected_frame)
 915         error (_("No frame selected."));
 916
 917       pc = get_frame_pc (deprecated_selected_frame);
 918       if (find_pc_partial_function (pc, &name, &low, &high) == 0)
 919         error (_("No function contains program counter for selected frame."));
 920 #if defined(TUI)
 921       /* NOTE: cagney/2003-02-13 The `tui_active' was previously
 922          `tui_version'.  */
 923       if (tui_active)
 924         /* FIXME: cagney/2004-02-07: This should be an observer.  */
 925         low = tui_get_low_disassembly_address (low, pc);
 926 #endif
 927       low += DEPRECATED_FUNCTION_START_OFFSET;
 928     }
 929   else if (!(space_index = (char *) strchr (arg, ' ')))
 930     {
 931       /* One argument.  */
 932       pc = parse_and_eval_address (arg);
 933       if (find_pc_partial_function (pc, &name, &low, &high) == 0)
 934         error (_("No function contains specified address."));
 935 #if defined(TUI)
 936       /* NOTE: cagney/2003-02-13 The `tui_active' was previously
 937          `tui_version'.  */
 938       if (tui_active)
 939         /* FIXME: cagney/2004-02-07: This should be an observer.  */
 940         low = tui_get_low_disassembly_address (low, pc);
 941 #endif
 942       low += DEPRECATED_FUNCTION_START_OFFSET;
 943     }
 944   else
 945     {
 946       /* Two arguments.  */
 947       *space_index = '\0';
 948       low = parse_and_eval_address (arg);
 949       high = parse_and_eval_address (space_index + 1);
 950     }
 951
 952 #if defined(TUI)
 953   if (!tui_is_window_visible (DISASSEM_WIN))
 954 #endif
 955     {
 956       printf_filtered ("Dump of assembler code ");
 957       if (name != NULL)
 958         {
 959           printf_filtered ("for function %s:\n", name);
 960         }
 961       else
 962         {
 963           printf_filtered ("from ");
 964           deprecated_print_address_numeric (low, 1, gdb_stdout);
 965           printf_filtered (" to ");
 966           deprecated_print_address_numeric (high, 1, gdb_stdout);
 967           printf_filtered (":\n");
 968         }
 969
 970       /* Dump the specified range.  */
 971       gdb_disassembly (uiout, 0, 0, 0, -1, low, high);
 972
 973       printf_filtered ("End of assembler dump.\n");
 974       gdb_flush (gdb_stdout);
 975     }
 976 #if defined(TUI)
 977   else
 978     {
 979       tui_show_assembly (low);
 980     }
 981 #endif
 982 }
 983
 984 static void
 985 make_command (char *arg, int from_tty)
 986 {
 987   char *p;
 988
 989   if (arg == 0)
 990     p = "make";
 991   else
 992     {
 993       p = xmalloc (sizeof ("make ") + strlen (arg));
 994       strcpy (p, "make ");
 995       strcpy (p + sizeof ("make ") - 1, arg);
 996     }
 997
 998   shell_escape (p, from_tty);
 999 }
1000
1001 static void
1002 show_user (char *args, int from_tty)
1003 {
1004   struct cmd_list_element *c;
1005   extern struct cmd_list_element *cmdlist;
1006
1007   if (args)
1008     {
1009       c = lookup_cmd (&args, cmdlist, "", 0, 1);
1010       if (c->class != class_user)
1011         error (_("Not a user command."));
1012       show_user_1 (c, gdb_stdout);
1013     }
1014   else
1015     {
1016       for (c = cmdlist; c; c = c->next)
1017         {
1018           if (c->class == class_user)
1019             show_user_1 (c, gdb_stdout);
1020         }
1021     }
1022 }
1023
1024 /* Search through names of commands and documentations for a certain
1025    regular expression.
1026 */
1027 void
1028 apropos_command (char *searchstr, int from_tty)
1029 {
1030   extern struct cmd_list_element *cmdlist; /*This is the main command list*/
1031   regex_t pattern;
1032   char *pattern_fastmap;
1033   char errorbuffer[512];
1034   pattern_fastmap = xcalloc (256, sizeof (char));
1035   if (searchstr == NULL)
1036       error (_("REGEXP string is empty"));
1037
1038   if (regcomp(&pattern,searchstr,REG_ICASE) == 0)
1039     {
1040       pattern.fastmap=pattern_fastmap;
1041       re_compile_fastmap(&pattern);
1042       apropos_cmd (gdb_stdout,cmdlist,&pattern,"");
1043     }
1044   else
1045     {
1046       regerror(regcomp(&pattern,searchstr,REG_ICASE),NULL,errorbuffer,512);
1047       error (_("Error in regular expression:%s"),errorbuffer);
1048     }
1049   xfree (pattern_fastmap);
1050 }
1051 \f
1052 /* Print a list of files and line numbers which a user may choose from
1053    in order to list a function which was specified ambiguously (as with
1054    `list classname::overloadedfuncname', for example).  The vector in
1055    SALS provides the filenames and line numbers.  */
1056
1057 static void
1058 ambiguous_line_spec (struct symtabs_and_lines *sals)
1059 {
1060   int i;
1061
1062   for (i = 0; i < sals->nelts; ++i)
1063     printf_filtered (_("file: \"%s\", line number: %d\n"),
1064                      sals->sals[i].symtab->filename, sals->sals[i].line);
1065 }
1066
1067 static void
1068 set_debug (char *arg, int from_tty)
1069 {
1070   printf_unfiltered (_("\"set debug\" must be followed by the name of a print subcommand.\n"));
1071   help_list (setdebuglist, "set debug ", -1, gdb_stdout);
1072 }
1073
1074 static void
1075 show_debug (char *args, int from_tty)
1076 {
1077   cmd_show_list (showdebuglist, from_tty, "");
1078 }
1079
1080 void
1081 init_cmd_lists (void)
1082 {
1083   max_user_call_depth = 1024;
1084
1085   cmdlist = NULL;
1086   infolist = NULL;
1087   enablelist = NULL;
1088   disablelist = NULL;
1089   togglelist = NULL;
1090   stoplist = NULL;
1091   deletelist = 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 }