gdb/main.c

   1 /* Top level `main' program for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "gdbcmd.h"
  22 #include "symtab.h"
  23 #include "inferior.h"
  24 #include "signals.h"
  25 #include "target.h"
  26 #include "breakpoint.h"
  27 #include "gdbtypes.h"
  28 #include "expression.h"
  29 #include "language.h"
  30
  31 #include "getopt.h"
  32
  33 /* readline include files */
  34 #include "readline.h"
  35 #include "history.h"
  36
  37 /* readline defines this.  */
  38 #undef savestring
  39
  40 #ifdef USG
  41 #include <sys/types.h>
  42 #include <unistd.h>
  43 #endif
  44
  45 #include <string.h>
  46 #ifndef NO_SYS_FILE
  47 #include <sys/file.h>
  48 #endif
  49 #include <setjmp.h>
  50 #include <sys/param.h>
  51 #include <sys/stat.h>
  52 #include <ctype.h>
  53
  54 #ifdef SET_STACK_LIMIT_HUGE
  55 #include <sys/time.h>
  56 #include <sys/resource.h>
  57
  58 int original_stack_limit;
  59 #endif
  60
  61 /* Prototypes for local functions */
  62
  63 static char *
  64 symbol_completion_function PARAMS ((char *, int));
  65
  66 static void
  67 command_loop PARAMS ((void));
  68
  69 static void
  70 command_loop_marker PARAMS ((int));
  71
  72 static void
  73 print_gdb_version PARAMS ((void));
  74
  75 static void
  76 quit_command PARAMS ((char *, int));
  77
  78 static void
  79 initialize_main PARAMS ((void));
  80
  81 static void
  82 initialize_history PARAMS ((void));
  83
  84 static void
  85 initialize_cmd_lists PARAMS ((void));
  86
  87 static void
  88 float_handler PARAMS ((int));
  89
  90 static void
  91 source_command PARAMS ((char *, int));
  92
  93 static void
  94 cd_command PARAMS ((char *, int));
  95
  96 static void
  97 print_gnu_advertisement PARAMS ((void));
  98
  99 static void
 100 init_signals PARAMS ((void));
 101
 102 static void
 103 read_command_file PARAMS ((FILE *));
 104
 105 static void
 106 set_verbose PARAMS ((char *, int, struct cmd_list_element *));
 107
 108 static void
 109 show_history PARAMS ((char *, int));
 110
 111 static void
 112 set_history PARAMS ((char *, int));
 113
 114 static void
 115 set_history_size_command PARAMS ((char *, int, struct cmd_list_element *));
 116
 117 static void
 118 show_commands PARAMS ((char *, int));
 119
 120 static void
 121 dump_me_command PARAMS ((char *, int));
 122
 123 static void
 124 echo_command PARAMS ((char *, int));
 125
 126 static void
 127 pwd_command PARAMS ((char *, int));
 128
 129 static void
 130 show_version PARAMS ((char *, int));
 131
 132 static void
 133 document_command PARAMS ((char *, int));
 134
 135 static void
 136 define_command PARAMS ((char *, int));
 137
 138 static void
 139 validate_comname PARAMS ((char *));
 140
 141 static void
 142 help_command PARAMS ((char *, int));
 143
 144 static void
 145 show_command PARAMS ((char *, int));
 146
 147 static void
 148 info_command PARAMS ((char *, int));
 149
 150 static void
 151 do_nothing PARAMS ((int));
 152
 153 static void
 154 disconnect PARAMS ((int));
 155
 156 static void
 157 source_cleanup PARAMS ((FILE *));
 158
 159 /* If this definition isn't overridden by the header files, assume
 160    that isatty and fileno exist on this system.  */
 161 #ifndef ISATTY
 162 #define ISATTY(FP)      (isatty (fileno (FP)))
 163 #endif
 164
 165 /* Initialization file name for gdb.  This is overridden in some configs.  */
 166
 167 #ifndef GDBINIT_FILENAME
 168 #define GDBINIT_FILENAME        ".gdbinit"
 169 #endif
 170 char gdbinit[] = GDBINIT_FILENAME;
 171
 172 #define ALL_CLEANUPS    ((struct cleanup *)0)
 173
 174 /* Version number of GDB, as a string.  */
 175
 176 extern char *version;
 177
 178 /* Message to be printed before the error message, when an error occurs.  */
 179
 180 extern char *error_pre_print;
 181
 182 /* Message to be printed before the warning message, when a warning occurs.  */
 183
 184 extern char *warning_pre_print;
 185
 186 extern char lang_frame_mismatch_warn[];         /* language.c */
 187
 188 /* Whether GDB's stdin is on a terminal.  */
 189
 190 extern int gdb_has_a_terminal;                  /* inflow.c */
 191
 192 /* Flag for whether we want all the "from_tty" gubbish printed.  */
 193
 194 int caution = 1;                        /* Default is yes, sigh. */
 195
 196 /*
 197  * Define all cmd_list_element's
 198  */
 199
 200 /* Chain containing all defined commands.  */
 201
 202 struct cmd_list_element *cmdlist;
 203
 204 /* Chain containing all defined info subcommands.  */
 205
 206 struct cmd_list_element *infolist;
 207
 208 /* Chain containing all defined enable subcommands. */
 209
 210 struct cmd_list_element *enablelist;
 211
 212 /* Chain containing all defined disable subcommands. */
 213
 214 struct cmd_list_element *disablelist;
 215
 216 /* Chain containing all defined delete subcommands. */
 217
 218 struct cmd_list_element *deletelist;
 219
 220 /* Chain containing all defined "enable breakpoint" subcommands. */
 221
 222 struct cmd_list_element *enablebreaklist;
 223
 224 /* Chain containing all defined set subcommands */
 225
 226 struct cmd_list_element *setlist;
 227
 228 /* Chain containing all defined show subcommands.  */
 229 struct cmd_list_element *showlist;
 230
 231 /* Chain containing all defined \"set history\".  */
 232
 233 struct cmd_list_element *sethistlist;
 234
 235 /* Chain containing all defined \"show history\".  */
 236 struct cmd_list_element *showhistlist;
 237
 238 /* Chain containing all defined \"unset history\".  */
 239
 240 struct cmd_list_element *unsethistlist;
 241
 242 /* stdio stream that command input is being read from.  */
 243
 244 FILE *instream;
 245
 246 /* Current working directory.  */
 247
 248 char *current_directory;
 249
 250 /* The directory name is actually stored here (usually).  */
 251 static char dirbuf[1024];
 252
 253 /* Function to call before reading a command, if nonzero.
 254    The function receives two args: an input stream,
 255    and a prompt string.  */
 256
 257 void (*window_hook) PARAMS ((FILE *, char *));
 258
 259 extern int frame_file_full_name;
 260 extern int mapped_symbol_files;
 261 extern int readnow_symbol_files;
 262
 263 int epoch_interface;
 264 int xgdb_verbose;
 265
 266 /* gdb prints this when reading a command interactively */
 267 static char *prompt;
 268
 269 /* Buffer used for reading command lines, and the size
 270    allocated for it so far.  */
 271
 272 char *line;
 273 int linesize = 100;
 274
 275 /* Baud rate specified for talking to serial target systems.  Default
 276    is left as a zero pointer, so targets can choose their own defaults.  */
 277
 278 char *baud_rate;
 279
 280 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT.  */
 281
 282 #ifndef STOP_SIGNAL
 283 #ifdef SIGTSTP
 284 #define STOP_SIGNAL SIGTSTP
 285 static void stop_sig PARAMS ((int));
 286 #endif
 287 #endif
 288
 289 /* Some System V have job control but not sigsetmask(). */
 290 #if !defined (HAVE_SIGSETMASK)
 291 #define HAVE_SIGSETMASK !defined (USG)
 292 #endif
 293
 294 #if 0 == (HAVE_SIGSETMASK)
 295 #define sigsetmask(n)
 296 #endif
 297 \f
 298 /* This is how `error' returns to command level.  */
 299
 300 jmp_buf to_top_level;
 301
 302 NORETURN void
 303 return_to_top_level ()
 304 {
 305   quit_flag = 0;
 306   immediate_quit = 0;
 307   bpstat_clear_actions(stop_bpstat);    /* Clear queued breakpoint commands */
 308   disable_current_display ();
 309   do_cleanups (ALL_CLEANUPS);
 310   (NORETURN void) longjmp (to_top_level, 1);
 311 }
 312
 313 /* Call FUNC with arg ARGS, catching any errors.
 314    If there is no error, return the value returned by FUNC.
 315    If there is an error, print ERRSTRING, print the specific error message,
 316                          then return zero.  */
 317
 318 int
 319 catch_errors (func, args, errstring)
 320      int (*func) PARAMS ((char *));
 321      char *args;
 322      char *errstring;
 323 {
 324   jmp_buf saved;
 325   int val;
 326   struct cleanup *saved_cleanup_chain;
 327   char *saved_error_pre_print;
 328
 329   saved_cleanup_chain = save_cleanups ();
 330   saved_error_pre_print = error_pre_print;
 331
 332   memcpy ((char *)saved, (char *)to_top_level, sizeof (jmp_buf));
 333   error_pre_print = errstring;
 334
 335   if (setjmp (to_top_level) == 0)
 336     val = (*func) (args);
 337   else
 338     val = 0;
 339
 340   restore_cleanups (saved_cleanup_chain);
 341
 342   error_pre_print = saved_error_pre_print;
 343   memcpy ((char *)to_top_level, (char *)saved, sizeof (jmp_buf));
 344   return val;
 345 }
 346
 347 /* Handler for SIGHUP.  */
 348
 349 static void
 350 disconnect (signo)
 351 int signo;
 352 {
 353   kill_inferior_fast ();
 354   signal (signo, SIG_DFL);
 355   kill (getpid (), SIGHUP);
 356 }
 357 \f
 358 /* Clean up on error during a "source" command (or execution of a
 359    user-defined command).  */
 360
 361 static void
 362 source_cleanup (stream)
 363      FILE *stream;
 364 {
 365   /* Restore the previous input stream.  */
 366   instream = stream;
 367 }
 368
 369 /* Read commands from STREAM.  */
 370 static void
 371 read_command_file (stream)
 372      FILE *stream;
 373 {
 374   struct cleanup *cleanups;
 375
 376   cleanups = make_cleanup (source_cleanup, instream);
 377   instream = stream;
 378   command_loop ();
 379   do_cleanups (cleanups);
 380 }
 381 \f
 382 int
 383 main (argc, argv)
 384      int argc;
 385      char **argv;
 386 {
 387   int count;
 388   static int inhibit_gdbinit = 0;
 389   static int quiet = 0;
 390   static int batch = 0;
 391
 392   /* Pointers to various arguments from command line.  */
 393   char *symarg = NULL;
 394   char *execarg = NULL;
 395   char *corearg = NULL;
 396   char *cdarg = NULL;
 397   char *ttyarg = NULL;
 398
 399   /* Pointers to all arguments of +command option.  */
 400   char **cmdarg;
 401   /* Allocated size of cmdarg.  */
 402   int cmdsize;
 403   /* Number of elements of cmdarg used.  */
 404   int ncmd;
 405
 406   /* Indices of all arguments of +directory option.  */
 407   char **dirarg;
 408   /* Allocated size.  */
 409   int dirsize;
 410   /* Number of elements used.  */
 411   int ndir;
 412
 413   register int i;
 414
 415   /* This needs to happen before the first use of malloc.  */
 416   init_malloc ((PTR) NULL);
 417
 418 #if defined (ALIGN_STACK_ON_STARTUP)
 419   i = (int) &count & 0x3;
 420   if (i != 0)
 421     alloca (4 - i);
 422 #endif
 423
 424   /* If error() is called from initialization code, just exit */
 425   if (setjmp (to_top_level)) {
 426     exit(1);
 427   }
 428
 429   cmdsize = 1;
 430   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 431   ncmd = 0;
 432   dirsize = 1;
 433   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 434   ndir = 0;
 435
 436   quit_flag = 0;
 437   line = (char *) xmalloc (linesize);
 438   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 439   instream = stdin;
 440
 441   getcwd (dirbuf, sizeof (dirbuf));
 442   current_directory = dirbuf;
 443
 444 #ifdef SET_STACK_LIMIT_HUGE
 445   {
 446     struct rlimit rlim;
 447
 448     /* Set the stack limit huge so that alloca (particularly stringtab
 449      * in dbxread.c) does not fail. */
 450     getrlimit (RLIMIT_STACK, &rlim);
 451     original_stack_limit = rlim.rlim_cur;
 452     rlim.rlim_cur = rlim.rlim_max;
 453     setrlimit (RLIMIT_STACK, &rlim);
 454   }
 455 #endif /* SET_STACK_LIMIT_HUGE */
 456
 457   /* Parse arguments and options.  */
 458   {
 459     int c;
 460     static int print_help;
 461     /* When var field is 0, use flag field to record the equivalent
 462        short option (or arbitrary numbers starting at 10 for those
 463        with no equivalent).  */
 464     static struct option long_options[] =
 465       {
 466         {"readnow", no_argument, &readnow_symbol_files, 1},
 467         {"r", no_argument, &readnow_symbol_files, 1},
 468         {"mapped", no_argument, &mapped_symbol_files, 1},
 469         {"m", no_argument, &mapped_symbol_files, 1},
 470         {"quiet", no_argument, &quiet, 1},
 471         {"q", no_argument, &quiet, 1},
 472         {"nx", no_argument, &inhibit_gdbinit, 1},
 473         {"n", no_argument, &inhibit_gdbinit, 1},
 474         {"batch", no_argument, &batch, 1},
 475         {"epoch", no_argument, &epoch_interface, 1},
 476         {"fullname", no_argument, &frame_file_full_name, 1},
 477         {"f", no_argument, &frame_file_full_name, 1},
 478         {"help", no_argument, &print_help, 1},
 479         {"se", required_argument, 0, 10},
 480         {"symbols", required_argument, 0, 's'},
 481         {"s", required_argument, 0, 's'},
 482         {"exec", required_argument, 0, 'e'},
 483         {"e", required_argument, 0, 'e'},
 484         {"core", required_argument, 0, 'c'},
 485         {"c", required_argument, 0, 'c'},
 486         {"command", required_argument, 0, 'x'},
 487         {"x", required_argument, 0, 'x'},
 488         {"directory", required_argument, 0, 'd'},
 489         {"cd", required_argument, 0, 11},
 490         {"tty", required_argument, 0, 't'},
 491         {"baud", required_argument, 0, 'b'},
 492         {"b", required_argument, 0, 'b'},
 493 /* Allow machine descriptions to add more options... */
 494 #ifdef ADDITIONAL_OPTIONS
 495         ADDITIONAL_OPTIONS
 496 #endif
 497         {0, no_argument, 0, 0},
 498       };
 499
 500     while (1)
 501       {
 502         int option_index;
 503
 504         c = getopt_long_only (argc, argv, "",
 505                               long_options, &option_index);
 506         if (c == EOF)
 507           break;
 508
 509         /* Long option that takes an argument.  */
 510         if (c == 0 && long_options[option_index].flag == 0)
 511           c = long_options[option_index].val;
 512
 513         switch (c)
 514           {
 515           case 0:
 516             /* Long option that just sets a flag.  */
 517             break;
 518           case 10:
 519             symarg = optarg;
 520             execarg = optarg;
 521             break;
 522           case 11:
 523             cdarg = optarg;
 524             break;
 525           case 's':
 526             symarg = optarg;
 527             break;
 528           case 'e':
 529             execarg = optarg;
 530             break;
 531           case 'c':
 532             corearg = optarg;
 533             break;
 534           case 'x':
 535             cmdarg[ncmd++] = optarg;
 536             if (ncmd >= cmdsize)
 537               {
 538                 cmdsize *= 2;
 539                 cmdarg = (char **) xrealloc ((char *)cmdarg,
 540                                              cmdsize * sizeof (*cmdarg));
 541               }
 542             break;
 543           case 'd':
 544             dirarg[ndir++] = optarg;
 545             if (ndir >= dirsize)
 546               {
 547                 dirsize *= 2;
 548                 dirarg = (char **) xrealloc ((char *)dirarg,
 549                                              dirsize * sizeof (*dirarg));
 550               }
 551             break;
 552           case 't':
 553             ttyarg = optarg;
 554             break;
 555           case 'q':
 556             quiet = 1;
 557             break;
 558           case 'b':
 559             baud_rate = optarg;
 560             break;
 561 #ifdef ADDITIONAL_OPTION_CASES
 562           ADDITIONAL_OPTION_CASES
 563 #endif
 564           case '?':
 565             fprintf (stderr,
 566                      "Use `%s +help' for a complete list of options.\n",
 567                      argv[0]);
 568             exit (1);
 569           }
 570
 571       }
 572     if (print_help)
 573       {
 574         fputs ("\
 575 This is GDB, the GNU debugger.  Use the command\n\
 576     gdb [options] [executable [core-file]]\n\
 577 to enter the debugger.\n\
 578 \n\
 579 Options available are:\n\
 580   -help             Print this message.\n\
 581   -quiet            Do not print version number on startup.\n\
 582   -fullname         Output information used by emacs-GDB interface.\n\
 583   -epoch            Output information used by epoch emacs-GDB interface.\n\
 584   -batch            Exit after processing options.\n\
 585   -nx               Do not read .gdbinit file.\n\
 586   -tty=TTY          Use TTY for input/output by the program being debugged.\n\
 587   -cd=DIR           Change current directory to DIR.\n\
 588   -directory=DIR    Search for source files in DIR.\n\
 589   -command=FILE     Execute GDB commands from FILE.\n\
 590   -symbols=SYMFILE  Read symbols from SYMFILE.\n\
 591   -exec=EXECFILE    Use EXECFILE as the executable.\n\
 592   -se=FILE          Use FILE as symbol file and executable file.\n\
 593   -core=COREFILE    Analyze the core dump COREFILE.\n\
 594   -b BAUDRATE       Set serial port baud rate used for remote debugging.\n\
 595   -mapped           Use mapped symbol files if supported on this system.\n\
 596   -readnow          Fully read symbol files on first access.\n\
 597 ", stderr);
 598 #ifdef ADDITIONAL_OPTION_HELP
 599         fputs (ADDITIONAL_OPTION_HELP, stderr);
 600 #endif
 601         fputs ("\n\
 602 For more information, type \"help\" from within GDB, or consult the\n\
 603 GDB manual (available as on-line info or a printed manual).\n", stderr);
 604         /* Exiting after printing this message seems like
 605            the most useful thing to do.  */
 606         exit (0);
 607       }
 608
 609     /* OK, that's all the options.  The other arguments are filenames.  */
 610     count = 0;
 611     for (; optind < argc; optind++)
 612       switch (++count)
 613         {
 614         case 1:
 615           symarg = argv[optind];
 616           execarg = argv[optind];
 617           break;
 618         case 2:
 619           corearg = argv[optind];
 620           break;
 621         case 3:
 622           fprintf (stderr,
 623                    "Excess command line arguments ignored. (%s%s)\n",
 624                    argv[optind], (optind == argc - 1) ? "" : " ...");
 625           break;
 626         }
 627     if (batch)
 628       quiet = 1;
 629   }
 630
 631   /* Run the init function of each source file */
 632
 633   initialize_cmd_lists ();      /* This needs to be done first */
 634   initialize_all_files ();
 635   initialize_main ();           /* But that omits this file!  Do it now */
 636   init_signals ();
 637
 638   if (!quiet)
 639     {
 640       /* Print all the junk at the top, with trailing "..." if we are about
 641          to read a symbol file (possibly slowly).  */
 642       print_gnu_advertisement ();
 643       print_gdb_version ();
 644       if (symarg)
 645         printf_filtered ("..");
 646       wrap_here("");
 647       fflush (stdout);          /* Force to screen during slow operations */
 648     }
 649
 650   error_pre_print = "\n\n";
 651   warning_pre_print = "\n\nwarning: ";
 652
 653   /* Now perform all the actions indicated by the arguments.  */
 654   if (cdarg != NULL)
 655     {
 656       if (!setjmp (to_top_level))
 657         {
 658           cd_command (cdarg, 0);
 659           init_source_path ();
 660         }
 661     }
 662   do_cleanups (ALL_CLEANUPS);
 663
 664   for (i = 0; i < ndir; i++)
 665     if (!setjmp (to_top_level))
 666       directory_command (dirarg[i], 0);
 667   free (dirarg);
 668   do_cleanups (ALL_CLEANUPS);
 669
 670   if (execarg != NULL
 671       && symarg != NULL
 672       && strcmp (execarg, symarg) == 0)
 673     {
 674       /* The exec file and the symbol-file are the same.  If we can't open
 675          it, better only print one error message.  */
 676       if (!setjmp (to_top_level))
 677         {
 678           exec_file_command (execarg, !batch);
 679           symbol_file_command (symarg, 0);
 680         }
 681     }
 682   else
 683     {
 684       if (execarg != NULL)
 685         if (!setjmp (to_top_level))
 686           exec_file_command (execarg, !batch);
 687       if (symarg != NULL)
 688         if (!setjmp (to_top_level))
 689           symbol_file_command (symarg, 0);
 690     }
 691   do_cleanups (ALL_CLEANUPS);
 692
 693   /* After the symbol file has been read, print a newline to get us
 694      beyond the copyright line...  But errors should still set off
 695      the error message with a (single) blank line.  */
 696   if (!quiet)
 697     printf_filtered ("\n");
 698   error_pre_print = "\n";
 699   warning_pre_print = "\nwarning: ";
 700
 701   /* Set the initial language. */
 702   {
 703     struct partial_symtab *pst = find_main_psymtab ();
 704     enum language lang = language_unknown;
 705     if (pst == NULL) ;
 706 #if 0
 707     /* A better solution would set the language when reading the psymtab.
 708        This would win for symbol file formats that encode the langauge,
 709        such as DWARF.  But, we don't do that yet. FIXME */
 710     else if (pst->language != language_unknown)
 711         lang = pst->language;
 712 #endif
 713     else if (pst->filename != NULL)
 714       lang = deduce_language_from_filename (pst->filename);
 715     if (lang == language_unknown) /* Make C the default language */
 716         lang = language_c;
 717     set_language (lang);
 718   }
 719
 720   if (corearg != NULL)
 721     if (!setjmp (to_top_level))
 722       core_file_command (corearg, !batch);
 723     else if (isdigit (corearg[0]) && !setjmp (to_top_level))
 724       attach_command (corearg, !batch);
 725   do_cleanups (ALL_CLEANUPS);
 726
 727   if (ttyarg != NULL)
 728     if (!setjmp (to_top_level))
 729       tty_command (ttyarg, !batch);
 730   do_cleanups (ALL_CLEANUPS);
 731
 732 #ifdef ADDITIONAL_OPTION_HANDLER
 733   ADDITIONAL_OPTION_HANDLER;
 734 #endif
 735
 736   /* Error messages should no longer be distinguished with extra output. */
 737   error_pre_print = 0;
 738   warning_pre_print = "warning: ";
 739
 740   {
 741     struct stat homebuf, cwdbuf;
 742     char *homedir, *homeinit;
 743
 744     /* Read init file, if it exists in home directory  */
 745     homedir = getenv ("HOME");
 746     if (homedir)
 747       {
 748         homeinit = (char *) alloca (strlen (getenv ("HOME")) +
 749                                     strlen (gdbinit) + 10);
 750         strcpy (homeinit, getenv ("HOME"));
 751         strcat (homeinit, "/");
 752         strcat (homeinit, gdbinit);
 753         if (!inhibit_gdbinit && access (homeinit, R_OK) == 0)
 754           if (!setjmp (to_top_level))
 755             source_command (homeinit, 0);
 756         do_cleanups (ALL_CLEANUPS);
 757
 758         /* Do stats; no need to do them elsewhere since we'll only
 759            need them if homedir is set.  Make sure that they are
 760            zero in case one of them fails (this guarantees that they
 761            won't match if either exists).  */
 762
 763         memset (&homebuf, 0, sizeof (struct stat));
 764         memset (&cwdbuf, 0, sizeof (struct stat));
 765
 766         stat (homeinit, &homebuf);
 767         stat (gdbinit, &cwdbuf); /* We'll only need this if
 768                                          homedir was set.  */
 769       }
 770
 771     /* Read the input file in the current directory, *if* it isn't
 772        the same file (it should exist, also).  */
 773
 774     if (!homedir
 775         || bcmp ((char *) &homebuf,
 776                  (char *) &cwdbuf,
 777                  sizeof (struct stat)))
 778       if (!inhibit_gdbinit && access (gdbinit, R_OK) == 0)
 779         if (!setjmp (to_top_level))
 780           source_command (gdbinit, 0);
 781         do_cleanups (ALL_CLEANUPS);
 782   }
 783
 784   for (i = 0; i < ncmd; i++)
 785     if (!setjmp (to_top_level))
 786       {
 787         if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 788           read_command_file (stdin);
 789         else
 790           source_command (cmdarg[i], !batch);
 791         do_cleanups (ALL_CLEANUPS);
 792       }
 793   free (cmdarg);
 794
 795   /* Read in the old history after all the command files have been read. */
 796   initialize_history();
 797
 798   if (batch)
 799     {
 800       /* We have hit the end of the batch file.  */
 801       exit (0);
 802     }
 803
 804   /* Do any host- or target-specific hacks.  This is used for i960 targets
 805      to force the user to set a nindy target and spec its parameters.  */
 806
 807 #ifdef BEFORE_MAIN_LOOP_HOOK
 808   BEFORE_MAIN_LOOP_HOOK;
 809 #endif
 810
 811   /* The command loop.  */
 812
 813   while (1)
 814     {
 815       if (!setjmp (to_top_level))
 816         {
 817           do_cleanups (ALL_CLEANUPS);           /* Do complete cleanup */
 818           command_loop ();
 819           quit_command ((char *)0, instream == stdin);
 820         }
 821     }
 822   /* No exit -- exit is through quit_command.  */
 823 }
 824
 825 /* Execute the line P as a command.
 826    Pass FROM_TTY as second argument to the defining function.  */
 827
 828 void
 829 execute_command (p, from_tty)
 830      char *p;
 831      int from_tty;
 832 {
 833   register struct cmd_list_element *c;
 834   register struct command_line *cmdlines;
 835   register enum language flang;
 836   static const struct language_defn *saved_language = 0;
 837   static int warned = 0;
 838
 839   free_all_values ();
 840
 841   /* This can happen when command_line_input hits end of file.  */
 842   if (p == NULL)
 843       return;
 844
 845   while (*p == ' ' || *p == '\t') p++;
 846   if (*p)
 847     {
 848       char *arg;
 849
 850       c = lookup_cmd (&p, cmdlist, "", 0, 1);
 851       /* Pass null arg rather than an empty one.  */
 852       arg = *p ? p : 0;
 853       if (c->class == class_user)
 854         {
 855           struct cleanup *old_chain;
 856
 857           if (*p)
 858             error ("User-defined commands cannot take arguments.");
 859           cmdlines = c->user_commands;
 860           if (cmdlines == 0)
 861             /* Null command */
 862             return;
 863
 864           /* Set the instream to 0, indicating execution of a
 865              user-defined function.  */
 866           old_chain =  make_cleanup (source_cleanup, instream);
 867           instream = (FILE *) 0;
 868           while (cmdlines)
 869             {
 870               execute_command (cmdlines->line, 0);
 871               cmdlines = cmdlines->next;
 872             }
 873           do_cleanups (old_chain);
 874         }
 875       else if (c->type == set_cmd || c->type == show_cmd)
 876         do_setshow_command (arg, from_tty & caution, c);
 877       else if (c->function.cfunc == NO_FUNCTION)
 878         error ("That is not a command, just a help topic.");
 879       else
 880         (*c->function.cfunc) (arg, from_tty & caution);
 881    }
 882
 883   /* Tell the user if the language has changed (except first time).  */
 884   if (current_language != saved_language)
 885   {
 886     if (language_mode == language_mode_auto) {
 887       if (saved_language)
 888         language_info (1);      /* Print what changed.  */
 889     }
 890     saved_language = current_language;
 891     warned = 0;
 892   }
 893
 894   /* Warn the user if the working language does not match the
 895      language of the current frame.  Only warn the user if we are
 896      actually running the program, i.e. there is a stack. */
 897   /* FIXME:  This should be cacheing the frame and only running when
 898      the frame changes.  */
 899   if (target_has_stack)
 900   {
 901     flang = get_frame_language ();
 902     if (!warned
 903         && flang != language_unknown
 904         && flang != current_language->la_language)
 905     {
 906       printf_filtered ("%s\n", lang_frame_mismatch_warn);
 907       warned = 1;
 908     }
 909   }
 910 }
 911
 912 /* ARGSUSED */
 913 static void
 914 command_loop_marker (foo)
 915      int foo;
 916 {
 917 }
 918
 919 /* Read commands from `instream' and execute them
 920    until end of file or error reading instream.  */
 921 static void
 922 command_loop ()
 923 {
 924   struct cleanup *old_chain;
 925   char *command;
 926   int stdin_is_tty = ISATTY (stdin);
 927
 928   while (!feof (instream))
 929     {
 930       if (window_hook && instream == stdin)
 931         (*window_hook) (instream, prompt);
 932
 933       quit_flag = 0;
 934       if (instream == stdin && stdin_is_tty)
 935         reinitialize_more_filter ();
 936       old_chain = make_cleanup (command_loop_marker, 0);
 937       command = command_line_input (instream == stdin ? prompt : (char *) NULL,
 938                                       instream == stdin);
 939       if (command == 0)
 940         return;
 941       execute_command (command, instream == stdin);
 942       /* Do any commands attached to breakpoint we stopped at.  */
 943       bpstat_do_actions (&stop_bpstat);
 944       do_cleanups (old_chain);
 945     }
 946 }
 947 \f
 948 /* Commands call this if they do not want to be repeated by null lines.  */
 949
 950 void
 951 dont_repeat ()
 952 {
 953   /* If we aren't reading from standard input, we are saving the last
 954      thing read from stdin in line and don't want to delete it.  Null lines
 955      won't repeat here in any case.  */
 956   if (instream == stdin)
 957     *line = 0;
 958 }
 959 \f
 960 /* Read a line from the stream "instream" without command line editing.
 961
 962    It prints PRROMPT once at the start.
 963    Action is compatible with "readline", e.g. space for the result is
 964    malloc'd and should be freed by the caller.
 965
 966    A NULL return means end of file.  */
 967 char *
 968 gdb_readline (prrompt)
 969      char *prrompt;
 970 {
 971   int c;
 972   char *result;
 973   int input_index = 0;
 974   int result_size = 80;
 975
 976   if (prrompt)
 977     {
 978       printf (prrompt);
 979       fflush (stdout);
 980     }
 981
 982   result = (char *) xmalloc (result_size);
 983
 984   while (1)
 985     {
 986       /* Read from stdin if we are executing a user defined command.
 987          This is the right thing for prompt_for_continue, at least.  */
 988       c = fgetc (instream ? instream : stdin);
 989
 990       if (c == EOF)
 991         {
 992           free (result);
 993           return NULL;
 994         }
 995
 996       if (c == '\n')
 997         break;
 998
 999       result[input_index++] = c;
1000       while (input_index >= result_size)
1001         {
1002           result_size *= 2;
1003           result = (char *) xrealloc (result, result_size);
1004         }
1005     }
1006
1007   result[input_index++] = '\0';
1008   return result;
1009 }
1010
1011 /* Variables which control command line editing and history
1012    substitution.  These variables are given default values at the end
1013    of this file.  */
1014 static int command_editing_p;
1015 static int history_expansion_p;
1016 static int write_history_p;
1017 static int history_size;
1018 static char *history_filename;
1019
1020 /* Variables which are necessary for fancy command line editing.  */
1021 char *gdb_completer_word_break_characters =
1022   " \t\n!@#$%^&*()-+=|~`}{[]\"';:?/>.<,";
1023
1024 /* Functions that are used as part of the fancy command line editing.  */
1025
1026 /* This can be used for functions which don't want to complete on symbols
1027    but don't want to complete on anything else either.  */
1028 /* ARGSUSED */
1029 char **
1030 noop_completer (text)
1031      char *text;
1032 {
1033   return NULL;
1034 }
1035
1036 /* Generate symbol names one by one for the completer.  If STATE is
1037    zero, then we need to initialize, otherwise the initialization has
1038    already taken place.  TEXT is what we expect the symbol to start
1039    with.  RL_LINE_BUFFER is available to be looked at; it contains the
1040    entire text of the line.  RL_POINT is the offset in that line of
1041    the cursor.  You should pretend that the line ends at RL_POINT.
1042    The result is NULL if there are no more completions, else a char
1043    string which is a possible completion.  */
1044
1045 static char *
1046 symbol_completion_function (text, state)
1047      char *text;
1048      int state;
1049 {
1050   static char **list = (char **)NULL;
1051   static int index;
1052   char *output;
1053   extern char *rl_line_buffer;
1054   extern int rl_point;
1055   char *tmp_command, *p;
1056   struct cmd_list_element *c, *result_list;
1057
1058   if (!state)
1059     {
1060       /* Free the storage used by LIST, but not by the strings inside.  This is
1061          because rl_complete_internal () frees the strings. */
1062       if (list)
1063         free (list);
1064       list = 0;
1065       index = 0;
1066
1067       /* Decide whether to complete on a list of gdb commands or on
1068          symbols.  */
1069       tmp_command = (char *) alloca (rl_point + 1);
1070       p = tmp_command;
1071
1072       strncpy (tmp_command, rl_line_buffer, rl_point);
1073       tmp_command[rl_point] = '\0';
1074
1075       if (rl_point == 0)
1076         {
1077           /* An empty line we want to consider ambiguous; that is,
1078              it could be any command.  */
1079           c = (struct cmd_list_element *) -1;
1080           result_list = 0;
1081         }
1082       else
1083         c = lookup_cmd_1 (&p, cmdlist, &result_list, 1);
1084
1085       /* Move p up to the next interesting thing.  */
1086       while (*p == ' ' || *p == '\t')
1087         p++;
1088
1089       if (!c)
1090         /* He's typed something unrecognizable.  Sigh.  */
1091         list = (char **) 0;
1092       else if (c == (struct cmd_list_element *) -1)
1093         {
1094           /* If we didn't recognize everything up to the thing that
1095              needs completing, and we don't know what command it is
1096              yet, we are in trouble.  Part of the trouble might be
1097              that the list of delimiters used by readline includes
1098              '-', which we use in commands.  Check for this.  */
1099           if (p + strlen(text) != tmp_command + rl_point) {
1100             if (tmp_command[rl_point - strlen(text) - 1] == '-')
1101               text = p;
1102             else {
1103               /* This really should not produce an error.  Better would
1104                  be to pretend to hit RETURN here; this would produce a
1105                  response like "Ambiguous command: foo, foobar, etc",
1106                  and leave the line available for re-entry with ^P.  Instead,
1107                  this error blows away the user's typed input without
1108                  any way to get it back.  */
1109               error ("  Unrecognized command.");
1110             }
1111           }
1112
1113           /* He's typed something ambiguous.  This is easier.  */
1114           if (result_list)
1115             list = complete_on_cmdlist (*result_list->prefixlist, text);
1116           else
1117             list = complete_on_cmdlist (cmdlist, text);
1118         }
1119       else
1120         {
1121           /* If we've gotten this far, gdb has recognized a full
1122              command.  There are several possibilities:
1123
1124              1) We need to complete on the command.
1125              2) We need to complete on the possibilities coming after
1126              the command.
1127              2) We need to complete the text of what comes after the
1128              command.   */
1129
1130           if (!*p && *text)
1131             /* Always (might be longer versions of thie command).  */
1132             list = complete_on_cmdlist (result_list, text);
1133           else if (!*p && !*text)
1134             {
1135               if (c->prefixlist)
1136                 list = complete_on_cmdlist (*c->prefixlist, "");
1137               else
1138                 list = (*c->completer) ("");
1139             }
1140           else
1141             {
1142               if (c->prefixlist && !c->allow_unknown)
1143                 {
1144 #if 0
1145                   /* Something like "info adsfkdj".  But error() is not
1146                      the proper response; just return no completions
1147                      instead.  */
1148                   *p = '\0';
1149                   error ("\"%s\" command requires a subcommand.",
1150                          tmp_command);
1151 #else
1152                   list = NULL;
1153 #endif
1154                 }
1155               else
1156                 list = (*c->completer) (text);
1157             }
1158         }
1159     }
1160
1161   /* If the debugged program wasn't compiled with symbols, or if we're
1162      clearly completing on a command and no command matches, return
1163      NULL.  */
1164   if (!list)
1165     return ((char *)NULL);
1166
1167   output = list[index];
1168   if (output)
1169     index++;
1170
1171   return (output);
1172 }
1173 \f
1174 #ifdef STOP_SIGNAL
1175 static void
1176 stop_sig (signo)
1177 int signo;
1178 {
1179 #if STOP_SIGNAL == SIGTSTP
1180   signal (SIGTSTP, SIG_DFL);
1181   sigsetmask (0);
1182   kill (getpid (), SIGTSTP);
1183   signal (SIGTSTP, stop_sig);
1184 #else
1185   signal (STOP_SIGNAL, stop_sig);
1186 #endif
1187   printf ("%s", prompt);
1188   fflush (stdout);
1189
1190   /* Forget about any previous command -- null line now will do nothing.  */
1191   dont_repeat ();
1192 }
1193 #endif /* STOP_SIGNAL */
1194
1195 /* Initialize signal handlers. */
1196 static void
1197 do_nothing (signo)
1198 int signo;
1199 {
1200 }
1201
1202 static void
1203 init_signals ()
1204 {
1205   signal (SIGINT, request_quit);
1206
1207   /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
1208      passed to the inferior, which we don't want.  It would be
1209      possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
1210      on BSD4.3 systems using vfork, that can affect the
1211      GDB process as well as the inferior (the signal handling tables
1212      might be in memory, shared between the two).  Since we establish
1213      a handler for SIGQUIT, when we call exec it will set the signal
1214      to SIG_DFL for us.  */
1215   signal (SIGQUIT, do_nothing);
1216   if (signal (SIGHUP, do_nothing) != SIG_IGN)
1217     signal (SIGHUP, disconnect);
1218   signal (SIGFPE, float_handler);
1219 }
1220 \f
1221 /* Read one line from the command input stream `instream'
1222    into the local static buffer `linebuffer' (whose current length
1223    is `linelength').
1224    The buffer is made bigger as necessary.
1225    Returns the address of the start of the line.
1226
1227    NULL is returned for end of file.
1228
1229    *If* the instream == stdin & stdin is a terminal, the line read
1230    is copied into the file line saver (global var char *line,
1231    length linesize) so that it can be duplicated.
1232
1233    This routine either uses fancy command line editing or
1234    simple input as the user has requested.  */
1235
1236 char *
1237 command_line_input (prrompt, repeat)
1238      char *prrompt;
1239      int repeat;
1240 {
1241   static char *linebuffer = 0;
1242   static unsigned linelength = 0;
1243   register char *p;
1244   char *p1;
1245   char *rl;
1246   char *local_prompt = prrompt;
1247   register int c;
1248   char *nline;
1249   char got_eof = 0;
1250
1251   if (linebuffer == 0)
1252     {
1253       linelength = 80;
1254       linebuffer = (char *) xmalloc (linelength);
1255     }
1256
1257   p = linebuffer;
1258
1259   /* Control-C quits instantly if typed while in this loop
1260      since it should not wait until the user types a newline.  */
1261   immediate_quit++;
1262 #ifdef STOP_SIGNAL
1263   signal (STOP_SIGNAL, stop_sig);
1264 #endif
1265
1266   while (1)
1267     {
1268       /* Reports are that some Sys V's don't flush stdout/err on reads
1269          from stdin, when stdin/out are sockets rather than ttys.  So we
1270          have to do it ourselves, to make emacs-gdb and xxgdb work.
1271          On other machines, doing this once per input should be a cheap nop.  */
1272       fflush (stdout);
1273       fflush (stderr);
1274
1275       /* Don't use fancy stuff if not talking to stdin.  */
1276       if (command_editing_p && instream == stdin
1277           && ISATTY (instream))
1278         rl = readline (local_prompt);
1279       else
1280         rl = gdb_readline (local_prompt);
1281
1282       if (!rl || rl == (char *) EOF)
1283         {
1284           got_eof = 1;
1285           break;
1286         }
1287       if (strlen(rl) + 1 + (p - linebuffer) > linelength)
1288         {
1289           linelength = strlen(rl) + 1 + (p - linebuffer);
1290           nline = (char *) xrealloc (linebuffer, linelength);
1291           p += nline - linebuffer;
1292           linebuffer = nline;
1293         }
1294       p1 = rl;
1295       /* Copy line.  Don't copy null at end.  (Leaves line alone
1296          if this was just a newline)  */
1297       while (*p1)
1298         *p++ = *p1++;
1299
1300       free (rl);                        /* Allocated in readline.  */
1301
1302       if (p == linebuffer || *(p - 1) != '\\')
1303         break;
1304
1305       p--;                      /* Put on top of '\'.  */
1306       local_prompt = (char *) 0;
1307   }
1308
1309 #ifdef STOP_SIGNAL
1310   signal (SIGTSTP, SIG_DFL);
1311 #endif
1312   immediate_quit--;
1313
1314   if (got_eof)
1315     return NULL;
1316
1317   /* Do history expansion if that is wished.  */
1318   if (history_expansion_p && instream == stdin
1319       && ISATTY (instream))
1320     {
1321       char *history_value;
1322       int expanded;
1323
1324       *p = '\0';                /* Insert null now.  */
1325       expanded = history_expand (linebuffer, &history_value);
1326       if (expanded)
1327         {
1328           /* Print the changes.  */
1329           printf ("%s\n", history_value);
1330
1331           /* If there was an error, call this function again.  */
1332           if (expanded < 0)
1333             {
1334               free (history_value);
1335               return command_line_input (prrompt, repeat);
1336             }
1337           if (strlen (history_value) > linelength)
1338             {
1339               linelength = strlen (history_value) + 1;
1340               linebuffer = (char *) xrealloc (linebuffer, linelength);
1341             }
1342           strcpy (linebuffer, history_value);
1343           p = linebuffer + strlen(linebuffer);
1344           free (history_value);
1345         }
1346     }
1347
1348   /* If we just got an empty line, and that is supposed
1349      to repeat the previous command, return the value in the
1350      global buffer.  */
1351   if (repeat)
1352     {
1353       if (p == linebuffer)
1354         return line;
1355       p1 = linebuffer;
1356       while (*p1 == ' ' || *p1 == '\t')
1357         p1++;
1358       if (!*p1)
1359         return line;
1360     }
1361
1362   *p = 0;
1363
1364   /* Add line to history if appropriate.  */
1365   if (instream == stdin
1366       && ISATTY (stdin) && *linebuffer)
1367     add_history (linebuffer);
1368
1369   /* Note: lines consisting soley of comments are added to the command
1370      history.  This is useful when you type a command, and then
1371      realize you don't want to execute it quite yet.  You can comment
1372      out the command and then later fetch it from the value history
1373      and remove the '#'.  The kill ring is probably better, but some
1374      people are in the habit of commenting things out.  */
1375   p1 = linebuffer;
1376   while ((c = *p1++) != '\0')
1377     {
1378       if (c == '"')
1379         while ((c = *p1++) != '"')
1380           {
1381             /* Make sure an escaped '"' doesn't make us think the string
1382                is ended.  */
1383             if (c == '\\')
1384               parse_escape (&p1);
1385             if (c == '\0')
1386               break;
1387           }
1388       else if (c == '\'')
1389         while ((c = *p1++) != '\'')
1390           {
1391             /* Make sure an escaped '\'' doesn't make us think the string
1392                is ended.  */
1393             if (c == '\\')
1394               parse_escape (&p1);
1395             if (c == '\0')
1396               break;
1397           }
1398       else if (c == '#')
1399         {
1400           /* Found a comment.  */
1401           p1[-1] = '\0';
1402           break;
1403         }
1404     }
1405
1406   /* Save into global buffer if appropriate.  */
1407   if (repeat)
1408     {
1409       if (linelength > linesize)
1410         {
1411           line = xrealloc (line, linelength);
1412           linesize = linelength;
1413         }
1414       strcpy (line, linebuffer);
1415       return line;
1416     }
1417
1418   return linebuffer;
1419 }
1420 \f
1421 /* Read lines from the input stream
1422    and accumulate them in a chain of struct command_line's
1423    which is then returned.  */
1424
1425 struct command_line *
1426 read_command_lines ()
1427 {
1428   struct command_line *first = 0;
1429   register struct command_line *next, *tail = 0;
1430   register char *p, *p1;
1431   struct cleanup *old_chain = 0;
1432
1433   while (1)
1434     {
1435       dont_repeat ();
1436       p = command_line_input ((char *) NULL, instream == stdin);
1437       if (p == NULL)
1438         /* Treat end of file like "end".  */
1439         break;
1440
1441       /* Remove leading and trailing blanks.  */
1442       while (*p == ' ' || *p == '\t') p++;
1443       p1 = p + strlen (p);
1444       while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t')) p1--;
1445
1446       /* Is this "end"?  */
1447       if (p1 - p == 3 && !strncmp (p, "end", 3))
1448         break;
1449
1450       /* No => add this line to the chain of command lines.  */
1451       next = (struct command_line *) xmalloc (sizeof (struct command_line));
1452       next->line = savestring (p, p1 - p);
1453       next->next = 0;
1454       if (tail)
1455         {
1456           tail->next = next;
1457         }
1458       else
1459         {
1460           /* We just read the first line.
1461              From now on, arrange to throw away the lines we have
1462              if we quit or get an error while inside this function.  */
1463           first = next;
1464           old_chain = make_cleanup (free_command_lines, &first);
1465         }
1466       tail = next;
1467     }
1468
1469   dont_repeat ();
1470
1471   /* Now we are about to return the chain to our caller,
1472      so freeing it becomes his responsibility.  */
1473   if (first)
1474     discard_cleanups (old_chain);
1475   return first;
1476 }
1477
1478 /* Free a chain of struct command_line's.  */
1479
1480 void
1481 free_command_lines (lptr)
1482       struct command_line **lptr;
1483 {
1484   register struct command_line *l = *lptr;
1485   register struct command_line *next;
1486
1487   while (l)
1488     {
1489       next = l->next;
1490       free (l->line);
1491       free (l);
1492       l = next;
1493     }
1494 }
1495 \f
1496 /* Add an element to the list of info subcommands.  */
1497
1498 void
1499 add_info (name, fun, doc)
1500      char *name;
1501      void (*fun) PARAMS ((char *, int));
1502      char *doc;
1503 {
1504   add_cmd (name, no_class, fun, doc, &infolist);
1505 }
1506
1507 /* Add an alias to the list of info subcommands.  */
1508
1509 void
1510 add_info_alias (name, oldname, abbrev_flag)
1511      char *name;
1512      char *oldname;
1513      int abbrev_flag;
1514 {
1515   add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
1516 }
1517
1518 /* The "info" command is defined as a prefix, with allow_unknown = 0.
1519    Therefore, its own definition is called only for "info" with no args.  */
1520
1521 /* ARGSUSED */
1522 static void
1523 info_command (arg, from_tty)
1524      char *arg;
1525      int from_tty;
1526 {
1527   printf ("\"info\" must be followed by the name of an info command.\n");
1528   help_list (infolist, "info ", -1, stdout);
1529 }
1530
1531 /* The "show" command with no arguments shows all the settings.  */
1532
1533 /* ARGSUSED */
1534 static void
1535 show_command (arg, from_tty)
1536      char *arg;
1537      int from_tty;
1538 {
1539   cmd_show_list (showlist, from_tty, "");
1540 }
1541 \f
1542 /* Add an element to the list of commands.  */
1543
1544 void
1545 add_com (name, class, fun, doc)
1546      char *name;
1547      enum command_class class;
1548      void (*fun) PARAMS ((char *, int));
1549      char *doc;
1550 {
1551   add_cmd (name, class, fun, doc, &cmdlist);
1552 }
1553
1554 /* Add an alias or abbreviation command to the list of commands.  */
1555
1556 void
1557 add_com_alias (name, oldname, class, abbrev_flag)
1558      char *name;
1559      char *oldname;
1560      enum command_class class;
1561      int abbrev_flag;
1562 {
1563   add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
1564 }
1565
1566 void
1567 error_no_arg (why)
1568      char *why;
1569 {
1570   error ("Argument required (%s).", why);
1571 }
1572
1573 /* ARGSUSED */
1574 static void
1575 help_command (command, from_tty)
1576      char *command;
1577      int from_tty; /* Ignored */
1578 {
1579   help_cmd (command, stdout);
1580 }
1581 \f
1582 static void
1583 validate_comname (comname)
1584      char *comname;
1585 {
1586   register char *p;
1587
1588   if (comname == 0)
1589     error_no_arg ("name of command to define");
1590
1591   p = comname;
1592   while (*p)
1593     {
1594       if (!(*p >= 'A' && *p <= 'Z')
1595           && !(*p >= 'a' && *p <= 'z')
1596           && !(*p >= '0' && *p <= '9')
1597           && *p != '-')
1598         error ("Junk in argument list: \"%s\"", p);
1599       p++;
1600     }
1601 }
1602
1603 #ifdef IBM6000
1604
1605 lowercase (char *str)
1606 {
1607   while (*str) {
1608
1609     /* isupper(), tolower() are function calls in AIX. */
1610     if ( *str >= 'A' && *str <= 'Z')
1611       *str = *str + 'a' - 'A';
1612     ++str;
1613   }
1614 }
1615 #endif
1616
1617 static void
1618 define_command (comname, from_tty)
1619      char *comname;
1620      int from_tty;
1621 {
1622   register struct command_line *cmds;
1623   register struct cmd_list_element *c, *newc;
1624   char *tem = comname;
1625
1626   validate_comname (comname);
1627
1628 #ifdef IBM6000
1629
1630   /* If the rest of the commands will be case insensetive, this one
1631      should behave in the same manner. */
1632
1633   lowercase (comname);
1634 #endif
1635
1636   /* Look it up, and verify that we got an exact match.  */
1637   c = lookup_cmd (&tem, cmdlist, "", -1, 1);
1638   if (c && 0 != strcmp (comname, c->name))
1639     c = 0;
1640
1641   if (c)
1642     {
1643       if (c->class == class_user || c->class == class_alias)
1644         tem = "Redefine command \"%s\"? ";
1645       else
1646         tem = "Really redefine built-in command \"%s\"? ";
1647       if (!query (tem, comname))
1648         error ("Command \"%s\" not redefined.", comname);
1649     }
1650
1651   if (from_tty)
1652     {
1653       printf ("Type commands for definition of \"%s\".\n\
1654 End with a line saying just \"end\".\n", comname);
1655       fflush (stdout);
1656     }
1657   comname = savestring (comname, strlen (comname));
1658
1659   cmds = read_command_lines ();
1660
1661   if (c && c->class == class_user)
1662     free_command_lines (&c->user_commands);
1663
1664   newc = add_cmd (comname, class_user, not_just_help_class_command,
1665            (c && c->class == class_user)
1666            ? c->doc : savestring ("User-defined.", 13), &cmdlist);
1667   newc->user_commands = cmds;
1668 }
1669
1670 static void
1671 document_command (comname, from_tty)
1672      char *comname;
1673      int from_tty;
1674 {
1675   struct command_line *doclines;
1676   register struct cmd_list_element *c;
1677   char *tem = comname;
1678
1679   validate_comname (comname);
1680
1681   c = lookup_cmd (&tem, cmdlist, "", 0, 1);
1682
1683   if (c->class != class_user)
1684     error ("Command \"%s\" is built-in.", comname);
1685
1686   if (from_tty)
1687     printf ("Type documentation for \"%s\".\n\
1688 End with a line saying just \"end\".\n", comname);
1689
1690   doclines = read_command_lines ();
1691
1692   if (c->doc) free (c->doc);
1693
1694   {
1695     register struct command_line *cl1;
1696     register int len = 0;
1697
1698     for (cl1 = doclines; cl1; cl1 = cl1->next)
1699       len += strlen (cl1->line) + 1;
1700
1701     c->doc = (char *) xmalloc (len + 1);
1702     *c->doc = 0;
1703
1704     for (cl1 = doclines; cl1; cl1 = cl1->next)
1705       {
1706         strcat (c->doc, cl1->line);
1707         if (cl1->next)
1708           strcat (c->doc, "\n");
1709       }
1710   }
1711
1712   free_command_lines (&doclines);
1713 }
1714 \f
1715 static void
1716 print_gnu_advertisement()
1717 {
1718     printf ("\
1719 GDB is free software and you are welcome to distribute copies of it\n\
1720  under certain conditions; type \"show copying\" to see the conditions.\n\
1721 There is absolutely no warranty for GDB; type \"show warranty\" for details.\n\
1722 ");
1723 }
1724
1725 static void
1726 print_gdb_version ()
1727 {
1728   printf_filtered ("\
1729 GDB %s, Copyright 1992 Free Software Foundation, Inc.",
1730           version);
1731 }
1732
1733 /* ARGSUSED */
1734 static void
1735 show_version (args, from_tty)
1736      char *args;
1737      int from_tty;
1738 {
1739   immediate_quit++;
1740   print_gnu_advertisement ();
1741   print_gdb_version ();
1742   printf_filtered ("\n");
1743   immediate_quit--;
1744 }
1745 \f
1746 /* xgdb calls this to reprint the usual GDB prompt.  */
1747
1748 void
1749 print_prompt ()
1750 {
1751   printf ("%s", prompt);
1752   fflush (stdout);
1753 }
1754 \f
1755 static void
1756 quit_command (args, from_tty)
1757      char *args;
1758      int from_tty;
1759 {
1760   if (inferior_pid != 0 && target_has_execution)
1761     {
1762       if (query ("The program is running.  Quit anyway? "))
1763         {
1764           target_kill ();
1765         }
1766       else
1767         error ("Not confirmed.");
1768     }
1769   /* Save the history information if it is appropriate to do so.  */
1770   if (write_history_p && history_filename)
1771     write_history (history_filename);
1772   exit (0);
1773 }
1774
1775 /* Returns whether GDB is running on a terminal and whether the user
1776    desires that questions be asked of them on that terminal.  */
1777
1778 int
1779 input_from_terminal_p ()
1780 {
1781   return gdb_has_a_terminal && (instream == stdin) & caution;
1782 }
1783 \f
1784 /* ARGSUSED */
1785 static void
1786 pwd_command (args, from_tty)
1787      char *args;
1788      int from_tty;
1789 {
1790   if (args) error ("The \"pwd\" command does not take an argument: %s", args);
1791   getcwd (dirbuf, sizeof (dirbuf));
1792
1793   if (strcmp (dirbuf, current_directory))
1794     printf ("Working directory %s\n (canonically %s).\n",
1795             current_directory, dirbuf);
1796   else
1797     printf ("Working directory %s.\n", current_directory);
1798 }
1799
1800 static void
1801 cd_command (dir, from_tty)
1802      char *dir;
1803      int from_tty;
1804 {
1805   int len;
1806   int change;
1807
1808   /* If the new directory is absolute, repeat is a no-op; if relative,
1809      repeat might be useful but is more likely to be a mistake.  */
1810   dont_repeat ();
1811
1812   if (dir == 0)
1813     error_no_arg ("new working directory");
1814
1815   dir = tilde_expand (dir);
1816   make_cleanup (free, dir);
1817
1818   if (chdir (dir) < 0)
1819     perror_with_name (dir);
1820
1821   len = strlen (dir);
1822   dir = savestring (dir, len - (len > 1 && dir[len-1] == '/'));
1823   if (dir[0] == '/')
1824     current_directory = dir;
1825   else
1826     {
1827       current_directory = concat (current_directory, "/", dir, NULL);
1828       free (dir);
1829     }
1830
1831   /* Now simplify any occurrences of `.' and `..' in the pathname.  */
1832
1833   change = 1;
1834   while (change)
1835     {
1836       char *p;
1837       change = 0;
1838
1839       for (p = current_directory; *p;)
1840         {
1841           if (!strncmp (p, "/./", 2)
1842               && (p[2] == 0 || p[2] == '/'))
1843             strcpy (p, p + 2);
1844           else if (!strncmp (p, "/..", 3)
1845                    && (p[3] == 0 || p[3] == '/')
1846                    && p != current_directory)
1847             {
1848               char *q = p;
1849               while (q != current_directory && q[-1] != '/') q--;
1850               if (q != current_directory)
1851                 {
1852                   strcpy (q-1, p+3);
1853                   p = q-1;
1854                 }
1855             }
1856           else p++;
1857         }
1858     }
1859
1860   forget_cached_source_info ();
1861
1862   if (from_tty)
1863     pwd_command ((char *) 0, 1);
1864 }
1865 \f
1866 /* ARGSUSED */
1867 static void
1868 source_command (args, from_tty)
1869      char *args;
1870      int from_tty;
1871 {
1872   FILE *stream;
1873   struct cleanup *cleanups;
1874   char *file = args;
1875
1876   if (file == 0)
1877     /* Let source without arguments read .gdbinit.  */
1878     file = gdbinit;
1879
1880   file = tilde_expand (file);
1881   make_cleanup (free, file);
1882
1883   stream = fopen (file, "r");
1884   if (stream == 0)
1885     perror_with_name (file);
1886
1887   cleanups = make_cleanup (fclose, stream);
1888
1889   read_command_file (stream);
1890
1891   do_cleanups (cleanups);
1892 }
1893
1894 /* ARGSUSED */
1895 static void
1896 echo_command (text, from_tty)
1897      char *text;
1898      int from_tty;
1899 {
1900   char *p = text;
1901   register int c;
1902
1903   if (text)
1904     while (c = *p++)
1905       {
1906         if (c == '\\')
1907           {
1908             /* \ at end of argument is used after spaces
1909                so they won't be lost.  */
1910             if (*p == 0)
1911               return;
1912
1913             c = parse_escape (&p);
1914             if (c >= 0)
1915               printf_filtered ("%c", c);
1916           }
1917         else
1918           printf_filtered ("%c", c);
1919       }
1920
1921   /* Force this output to appear now.  */
1922   wrap_here ("");
1923   fflush (stdout);
1924 }
1925
1926 /* ARGSUSED */
1927 static void
1928 dump_me_command (args, from_tty)
1929      char *args;
1930      int from_tty;
1931 {
1932   if (query ("Should GDB dump core? "))
1933     {
1934       signal (SIGQUIT, SIG_DFL);
1935       kill (getpid (), SIGQUIT);
1936     }
1937 }
1938 \f
1939 /* Functions to manipulate command line editing control variables.  */
1940
1941 /* Number of commands to print in each call to show_commands.  */
1942 #define Hist_print 10
1943 static void
1944 show_commands (args, from_tty)
1945      char *args;
1946      int from_tty;
1947 {
1948   /* Index for history commands.  Relative to history_base.  */
1949   int offset;
1950
1951   /* Number of the history entry which we are planning to display next.
1952      Relative to history_base.  */
1953   static int num = 0;
1954
1955   /* The first command in the history which doesn't exist (i.e. one more
1956      than the number of the last command).  Relative to history_base.  */
1957   int hist_len;
1958
1959   extern struct _hist_entry *history_get PARAMS ((int));
1960   extern int history_base;
1961
1962   /* Print out some of the commands from the command history.  */
1963   /* First determine the length of the history list.  */
1964   hist_len = history_size;
1965   for (offset = 0; offset < history_size; offset++)
1966     {
1967       if (!history_get (history_base + offset))
1968         {
1969           hist_len = offset;
1970           break;
1971         }
1972     }
1973
1974   if (args)
1975     {
1976       if (args[0] == '+' && args[1] == '\0')
1977         /* "info editing +" should print from the stored position.  */
1978         ;
1979       else
1980         /* "info editing <exp>" should print around command number <exp>.  */
1981         num = (parse_and_eval_address (args) - history_base) - Hist_print / 2;
1982     }
1983   /* "show commands" means print the last Hist_print commands.  */
1984   else
1985     {
1986       num = hist_len - Hist_print;
1987     }
1988
1989   if (num < 0)
1990     num = 0;
1991
1992   /* If there are at least Hist_print commands, we want to display the last
1993      Hist_print rather than, say, the last 6.  */
1994   if (hist_len - num < Hist_print)
1995     {
1996       num = hist_len - Hist_print;
1997       if (num < 0)
1998         num = 0;
1999     }
2000
2001   for (offset = num; offset < num + Hist_print && offset < hist_len; offset++)
2002     {
2003       printf_filtered ("%5d  %s\n", history_base + offset,
2004               (history_get (history_base + offset))->line);
2005     }
2006
2007   /* The next command we want to display is the next one that we haven't
2008      displayed yet.  */
2009   num += Hist_print;
2010
2011   /* If the user repeats this command with return, it should do what
2012      "show commands +" does.  This is unnecessary if arg is null,
2013      because "show commands +" is not useful after "show commands".  */
2014   if (from_tty && args)
2015     {
2016       args[0] = '+';
2017       args[1] = '\0';
2018     }
2019 }
2020
2021 /* Called by do_setshow_command.  */
2022 /* ARGSUSED */
2023 static void
2024 set_history_size_command (args, from_tty, c)
2025      char *args;
2026      int from_tty;
2027      struct cmd_list_element *c;
2028 {
2029   if (history_size == UINT_MAX)
2030     unstifle_history ();
2031   else
2032     stifle_history (history_size);
2033 }
2034
2035 /* ARGSUSED */
2036 static void
2037 set_history (args, from_tty)
2038      char *args;
2039      int from_tty;
2040 {
2041   printf ("\"set history\" must be followed by the name of a history subcommand.\n");
2042   help_list (sethistlist, "set history ", -1, stdout);
2043 }
2044
2045 /* ARGSUSED */
2046 static void
2047 show_history (args, from_tty)
2048      char *args;
2049      int from_tty;
2050 {
2051   cmd_show_list (showhistlist, from_tty, "");
2052 }
2053
2054 int info_verbose = 0;           /* Default verbose msgs off */
2055
2056 /* Called by do_setshow_command.  An elaborate joke.  */
2057 /* ARGSUSED */
2058 static void
2059 set_verbose (args, from_tty, c)
2060      char *args;
2061      int from_tty;
2062      struct cmd_list_element *c;
2063 {
2064   char *cmdname = "verbose";
2065   struct cmd_list_element *showcmd;
2066
2067   showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
2068
2069   if (info_verbose)
2070     {
2071       c->doc = "Set verbose printing of informational messages.";
2072       showcmd->doc = "Show verbose printing of informational messages.";
2073     }
2074   else
2075     {
2076       c->doc = "Set verbosity.";
2077       showcmd->doc = "Show verbosity.";
2078     }
2079 }
2080
2081 static void
2082 float_handler (signo)
2083 int signo;
2084 {
2085   /* This message is based on ANSI C, section 4.7.  Note that integer
2086      divide by zero causes this, so "float" is a misnomer.  */
2087   error ("Erroneous arithmetic operation.");
2088 }
2089
2090 /* Return whether we are running a batch file or from terminal.  */
2091 int
2092 batch_mode ()
2093 {
2094   return !(instream == stdin && ISATTY (stdin));
2095 }
2096
2097 \f
2098 static void
2099 initialize_cmd_lists ()
2100 {
2101   cmdlist = (struct cmd_list_element *) 0;
2102   infolist = (struct cmd_list_element *) 0;
2103   enablelist = (struct cmd_list_element *) 0;
2104   disablelist = (struct cmd_list_element *) 0;
2105   deletelist = (struct cmd_list_element *) 0;
2106   enablebreaklist = (struct cmd_list_element *) 0;
2107   setlist = (struct cmd_list_element *) 0;
2108   showlist = NULL;
2109   sethistlist = (struct cmd_list_element *) 0;
2110   showhistlist = NULL;
2111   unsethistlist = (struct cmd_list_element *) 0;
2112 }
2113
2114 /* Init the history buffer.  Note that we are called after the init file(s)
2115  * have been read so that the user can change the history file via his
2116  * .gdbinit file (for instance).  The GDBHISTFILE environment variable
2117  * overrides all of this.
2118  */
2119
2120 static void
2121 initialize_history()
2122 {
2123   char *tmpenv;
2124
2125   tmpenv = getenv ("HISTSIZE");
2126   if (tmpenv)
2127     history_size = atoi (tmpenv);
2128   else if (!history_size)
2129     history_size = 256;
2130
2131   stifle_history (history_size);
2132
2133   tmpenv = getenv ("GDBHISTFILE");
2134   if (tmpenv)
2135     history_filename = savestring (tmpenv, strlen(tmpenv));
2136   else if (!history_filename) {
2137     /* We include the current directory so that if the user changes
2138        directories the file written will be the same as the one
2139        that was read.  */
2140     history_filename = concat (current_directory, "/.gdb_history", NULL);
2141   }
2142   read_history (history_filename);
2143 }
2144
2145 static void
2146 initialize_main ()
2147 {
2148   struct cmd_list_element *c;
2149
2150 #ifdef DEFAULT_PROMPT
2151   prompt = savestring (DEFAULT_PROMPT, strlen(DEFAULT_PROMPT));
2152 #else
2153   prompt = savestring ("(gdb) ", 6);
2154 #endif
2155
2156   /* Set the important stuff up for command editing.  */
2157   command_editing_p = 1;
2158   history_expansion_p = 0;
2159   write_history_p = 0;
2160
2161   /* Setup important stuff for command line editing.  */
2162   rl_completion_entry_function = (int (*)()) symbol_completion_function;
2163   rl_completer_word_break_characters = gdb_completer_word_break_characters;
2164   rl_readline_name = "gdb";
2165
2166   /* Define the classes of commands.
2167      They will appear in the help list in the reverse of this order.  */
2168
2169   add_cmd ("obscure", class_obscure, NO_FUNCTION, "Obscure features.", &cmdlist);
2170   add_cmd ("aliases", class_alias, NO_FUNCTION, "Aliases of other commands.", &cmdlist);
2171   add_cmd ("user-defined", class_user, NO_FUNCTION, "User-defined commands.\n\
2172 The commands in this class are those defined by the user.\n\
2173 Use the \"define\" command to define a command.", &cmdlist);
2174   add_cmd ("support", class_support, NO_FUNCTION, "Support facilities.", &cmdlist);
2175   add_cmd ("status", class_info, NO_FUNCTION, "Status inquiries.", &cmdlist);
2176   add_cmd ("files", class_files, NO_FUNCTION, "Specifying and examining files.", &cmdlist);
2177   add_cmd ("breakpoints", class_breakpoint, NO_FUNCTION, "Making program stop at certain points.", &cmdlist);
2178   add_cmd ("data", class_vars, NO_FUNCTION, "Examining data.", &cmdlist);
2179   add_cmd ("stack", class_stack, NO_FUNCTION, "Examining the stack.\n\
2180 The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
2181 counting from zero for the innermost (currently executing) frame.\n\n\
2182 At any time gdb identifies one frame as the \"selected\" frame.\n\
2183 Variable lookups are done with respect to the selected frame.\n\
2184 When the program being debugged stops, gdb selects the innermost frame.\n\
2185 The commands below can be used to select other frames by number or address.",
2186            &cmdlist);
2187   add_cmd ("running", class_run, NO_FUNCTION, "Running the program.", &cmdlist);
2188
2189   add_com ("pwd", class_files, pwd_command,
2190            "Print working directory.  This is used for your program as well.");
2191   add_com ("cd", class_files, cd_command,
2192            "Set working directory to DIR for debugger and program being debugged.\n\
2193 The change does not take effect for the program being debugged\n\
2194 until the next time it is started.");
2195
2196   add_show_from_set
2197     (add_set_cmd ("prompt", class_support, var_string, (char *)&prompt,
2198            "Set gdb's prompt",
2199            &setlist),
2200      &showlist);
2201
2202   add_com ("echo", class_support, echo_command,
2203            "Print a constant string.  Give string as argument.\n\
2204 C escape sequences may be used in the argument.\n\
2205 No newline is added at the end of the argument;\n\
2206 use \"\\n\" if you want a newline to be printed.\n\
2207 Since leading and trailing whitespace are ignored in command arguments,\n\
2208 if you want to print some you must use \"\\\" before leading whitespace\n\
2209 to be printed or after trailing whitespace.");
2210   add_com ("document", class_support, document_command,
2211            "Document a user-defined command.\n\
2212 Give command name as argument.  Give documentation on following lines.\n\
2213 End with a line of just \"end\".");
2214   add_com ("define", class_support, define_command,
2215            "Define a new command name.  Command name is argument.\n\
2216 Definition appears on following lines, one command per line.\n\
2217 End with a line of just \"end\".\n\
2218 Use the \"document\" command to give documentation for the new command.\n\
2219 Commands defined in this way do not take arguments.");
2220
2221 #ifdef __STDC__
2222   add_com ("source", class_support, source_command,
2223            "Read commands from a file named FILE.\n\
2224 Note that the file \"" GDBINIT_FILENAME "\" is read automatically in this way\n\
2225 when gdb is started.");
2226 #else
2227   /* Punt file name, we can't help it easily.  */
2228   add_com ("source", class_support, source_command,
2229            "Read commands from a file named FILE.\n\
2230 Note that the file \".gdbinit\" is read automatically in this way\n\
2231 when gdb is started.");
2232 #endif
2233
2234   add_com ("quit", class_support, quit_command, "Exit gdb.");
2235   add_com ("help", class_support, help_command, "Print list of commands.");
2236   add_com_alias ("q", "quit", class_support, 1);
2237   add_com_alias ("h", "help", class_support, 1);
2238
2239
2240   c = add_set_cmd ("verbose", class_support, var_boolean, (char *)&info_verbose,
2241                    "Set ",
2242                    &setlist),
2243   add_show_from_set (c, &showlist);
2244   c->function.sfunc = set_verbose;
2245   set_verbose (NULL, 0, c);
2246
2247   add_com ("dump-me", class_obscure, dump_me_command,
2248            "Get fatal error; make debugger dump its core.");
2249
2250   add_show_from_set
2251     (add_set_cmd ("editing", class_support, var_boolean, (char *)&command_editing_p,
2252            "Set editing of command lines as they are typed.\n\
2253 Use \"on\" to enable to enable the editing, and \"off\" to disable it.\n\
2254 Without an argument, command line editing is enabled.  To edit, use\n\
2255 EMACS-like or VI-like commands like control-P or ESC.", &setlist),
2256      &showlist);
2257
2258   add_prefix_cmd ("history", class_support, set_history,
2259                   "Generic command for setting command history parameters.",
2260                   &sethistlist, "set history ", 0, &setlist);
2261   add_prefix_cmd ("history", class_support, show_history,
2262                   "Generic command for showing command history parameters.",
2263                   &showhistlist, "show history ", 0, &showlist);
2264
2265   add_show_from_set
2266     (add_set_cmd ("expansion", no_class, var_boolean, (char *)&history_expansion_p,
2267            "Set history expansion on command input.\n\
2268 Without an argument, history expansion is enabled.", &sethistlist),
2269      &showhistlist);
2270
2271   add_show_from_set
2272     (add_set_cmd ("save", no_class, var_boolean, (char *)&write_history_p,
2273            "Set saving of the history record on exit.\n\
2274 Use \"on\" to enable to enable the saving, and \"off\" to disable it.\n\
2275 Without an argument, saving is enabled.", &sethistlist),
2276      &showhistlist);
2277
2278   c = add_set_cmd ("size", no_class, var_uinteger, (char *)&history_size,
2279                    "Set the size of the command history, \n\
2280 ie. the number of previous commands to keep a record of.", &sethistlist);
2281   add_show_from_set (c, &showhistlist);
2282   c->function.sfunc = set_history_size_command;
2283
2284   add_show_from_set
2285     (add_set_cmd ("filename", no_class, var_filename, (char *)&history_filename,
2286            "Set the filename in which to record the command history\n\
2287  (the list of previous commands of which a record is kept).", &sethistlist),
2288      &showhistlist);
2289
2290   add_show_from_set
2291     (add_set_cmd ("confirm", class_support, var_boolean,
2292                   (char *)&caution,
2293                   "Set whether to confirm potentially dangerous operations.",
2294                   &setlist),
2295      &showlist);
2296
2297   add_prefix_cmd ("info", class_info, info_command,
2298         "Generic command for showing things about the program being debugged.",
2299                   &infolist, "info ", 0, &cmdlist);
2300   add_com_alias ("i", "info", class_info, 1);
2301
2302   add_prefix_cmd ("show", class_info, show_command,
2303                   "Generic command for showing things about the debugger.",
2304                   &showlist, "show ", 0, &cmdlist);
2305   /* Another way to get at the same thing.  */
2306   add_info ("set", show_command, "Show all GDB settings.");
2307
2308   add_cmd ("commands", no_class, show_commands,
2309            "Show the the history of commands you typed.\n\
2310 You can supply a command number to start with, or a `+' to start after\n\
2311 the previous command number shown.",
2312            &showlist);
2313
2314   add_cmd ("version", no_class, show_version,
2315            "Show what version of GDB this is.", &showlist);
2316 }