gdb/top.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2    Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "gdbcmd.h"
  23 #include "call-cmds.h"
  24 #include "symtab.h"
  25 #include "inferior.h"
  26 #include "signals.h"
  27 #include "target.h"
  28 #include "breakpoint.h"
  29 #include "gdbtypes.h"
  30 #include "expression.h"
  31 #include "value.h"
  32 #include "language.h"
  33 #include "terminal.h" /* For job_control.  */
  34 #include "annotate.h"
  35 #include <setjmp.h>
  36 #include "top.h"
  37
  38 /* readline include files */
  39 #include "readline.h"
  40 #include "history.h"
  41
  42 /* readline defines this.  */
  43 #undef savestring
  44
  45 #include <sys/types.h>
  46 #ifdef HAVE_UNISTD_H
  47 #include <unistd.h>
  48 #endif
  49
  50 #include "gdb_string.h"
  51 #include "gdb_stat.h"
  52 #include <ctype.h>
  53
  54 extern void initialize_utils PARAMS ((void));
  55
  56 /* Prototypes for local functions */
  57
  58 static void dont_repeat_command PARAMS ((char *, int));
  59
  60 static void source_cleanup_lines PARAMS ((PTR));
  61
  62 static void user_defined_command PARAMS ((char *, int));
  63
  64 static void init_signals PARAMS ((void));
  65
  66 #ifdef STOP_SIGNAL
  67 static void stop_sig PARAMS ((int));
  68 #endif
  69
  70 static char * line_completion_function PARAMS ((char *, int, char *, int));
  71
  72 static char * readline_line_completion_function PARAMS ((char *, int));
  73
  74 static void command_loop_marker PARAMS ((int));
  75
  76 static void while_command PARAMS ((char *, int));
  77
  78 static void if_command PARAMS ((char *, int));
  79
  80 static struct command_line *
  81 build_command_line PARAMS ((enum command_control_type, char *));
  82
  83 static struct command_line *
  84 get_command_line PARAMS ((enum command_control_type, char *));
  85
  86 static void realloc_body_list PARAMS ((struct command_line *, int));
  87
  88 static enum misc_command_type read_next_line PARAMS ((struct command_line **));
  89
  90 static enum command_control_type
  91 recurse_read_control_structure PARAMS ((struct command_line *));
  92
  93 static struct cleanup * setup_user_args PARAMS ((char *));
  94
  95 static char * locate_arg PARAMS ((char *));
  96
  97 static char * insert_args PARAMS ((char *));
  98
  99 static void arg_cleanup PARAMS ((void));
 100
 101 static void init_main PARAMS ((void));
 102
 103 static void init_cmd_lists PARAMS ((void));
 104
 105 static void float_handler PARAMS ((int));
 106
 107 static void init_signals PARAMS ((void));
 108
 109 static void set_verbose PARAMS ((char *, int, struct cmd_list_element *));
 110
 111 static void set_endian PARAMS ((char *, int));
 112
 113 static void set_endian_big PARAMS ((char *, int));
 114
 115 static void set_endian_little PARAMS ((char *, int));
 116
 117 static void set_endian_auto PARAMS ((char *, int));
 118
 119 static void show_endian PARAMS ((char *, int));
 120
 121 static void set_architecture PARAMS ((char *, int));
 122
 123 static void show_architecture PARAMS ((char *, int));
 124
 125 static void info_architecture PARAMS ((char *, int));
 126
 127 static void show_history PARAMS ((char *, int));
 128
 129 static void set_history PARAMS ((char *, int));
 130
 131 static void set_history_size_command PARAMS ((char *, int,
 132                                               struct cmd_list_element *));
 133
 134 static void show_commands PARAMS ((char *, int));
 135
 136 static void echo_command PARAMS ((char *, int));
 137
 138 static void pwd_command PARAMS ((char *, int));
 139
 140 static void show_version PARAMS ((char *, int));
 141
 142 static void document_command PARAMS ((char *, int));
 143
 144 static void define_command PARAMS ((char *, int));
 145
 146 static void validate_comname PARAMS ((char *));
 147
 148 static void help_command PARAMS ((char *, int));
 149
 150 static void show_command PARAMS ((char *, int));
 151
 152 static void info_command PARAMS ((char *, int));
 153
 154 static void complete_command PARAMS ((char *, int));
 155
 156 static void do_nothing PARAMS ((int));
 157
 158 #ifdef SIGHUP
 159 static int quit_cover PARAMS ((char *));
 160
 161 static void disconnect PARAMS ((int));
 162 #endif
 163
 164 static void source_cleanup PARAMS ((FILE *));
 165
 166 /* If this definition isn't overridden by the header files, assume
 167    that isatty and fileno exist on this system.  */
 168 #ifndef ISATTY
 169 #define ISATTY(FP)      (isatty (fileno (FP)))
 170 #endif
 171
 172 /* Initialization file name for gdb.  This is overridden in some configs.  */
 173
 174 #ifndef GDBINIT_FILENAME
 175 #define GDBINIT_FILENAME        ".gdbinit"
 176 #endif
 177 char gdbinit[] = GDBINIT_FILENAME;
 178
 179 int inhibit_gdbinit = 0;
 180
 181 /* If nonzero, and GDB has been configured to be able to use windows,
 182    attempt to open them upon startup.  */
 183
 184 int use_windows = 1;
 185
 186 /* Version number of GDB, as a string.  */
 187
 188 extern char *version;
 189
 190 /* Canonical host name as a string. */
 191
 192 extern char *host_name;
 193
 194 /* Canonical target name as a string. */
 195
 196 extern char *target_name;
 197
 198 extern char lang_frame_mismatch_warn[];         /* language.c */
 199
 200 /* Flag for whether we want all the "from_tty" gubbish printed.  */
 201
 202 int caution = 1;                        /* Default is yes, sigh. */
 203
 204 /* Define all cmd_list_elements.  */
 205
 206 /* Chain containing all defined commands.  */
 207
 208 struct cmd_list_element *cmdlist;
 209
 210 /* Chain containing all defined info subcommands.  */
 211
 212 struct cmd_list_element *infolist;
 213
 214 /* Chain containing all defined enable subcommands. */
 215
 216 struct cmd_list_element *enablelist;
 217
 218 /* Chain containing all defined disable subcommands. */
 219
 220 struct cmd_list_element *disablelist;
 221
 222 /* Chain containing all defined delete subcommands. */
 223
 224 struct cmd_list_element *deletelist;
 225
 226 /* Chain containing all defined "enable breakpoint" subcommands. */
 227
 228 struct cmd_list_element *enablebreaklist;
 229
 230 /* Chain containing all defined set subcommands */
 231
 232 struct cmd_list_element *setlist;
 233
 234 /* Chain containing all defined unset subcommands */
 235
 236 struct cmd_list_element *unsetlist;
 237
 238 /* Chain containing all defined show subcommands.  */
 239
 240 struct cmd_list_element *showlist;
 241
 242 /* Chain containing the \"set endian\" commands.  */
 243
 244 struct cmd_list_element *endianlist;
 245
 246 /* Chain containing all defined \"set history\".  */
 247
 248 struct cmd_list_element *sethistlist;
 249
 250 /* Chain containing all defined \"show history\".  */
 251
 252 struct cmd_list_element *showhistlist;
 253
 254 /* Chain containing all defined \"unset history\".  */
 255
 256 struct cmd_list_element *unsethistlist;
 257
 258 /* Chain containing all defined maintenance subcommands. */
 259
 260 #if MAINTENANCE_CMDS
 261 struct cmd_list_element *maintenancelist;
 262 #endif
 263
 264 /* Chain containing all defined "maintenance info" subcommands. */
 265
 266 #if MAINTENANCE_CMDS
 267 struct cmd_list_element *maintenanceinfolist;
 268 #endif
 269
 270 /* Chain containing all defined "maintenance print" subcommands. */
 271
 272 #if MAINTENANCE_CMDS
 273 struct cmd_list_element *maintenanceprintlist;
 274 #endif
 275
 276 struct cmd_list_element *setprintlist;
 277
 278 struct cmd_list_element *showprintlist;
 279
 280 struct cmd_list_element *setchecklist;
 281
 282 struct cmd_list_element *showchecklist;
 283
 284 /* stdio stream that command input is being read from.  Set to stdin normally.
 285    Set by source_command to the file we are sourcing.  Set to NULL if we are
 286    executing a user-defined command or interacting via a GUI.  */
 287
 288 FILE *instream;
 289
 290 /* Current working directory.  */
 291
 292 char *current_directory;
 293
 294 /* The directory name is actually stored here (usually).  */
 295 char gdb_dirbuf[1024];
 296
 297 /* Function to call before reading a command, if nonzero.
 298    The function receives two args: an input stream,
 299    and a prompt string.  */
 300
 301 void (*window_hook) PARAMS ((FILE *, char *));
 302
 303 int epoch_interface;
 304 int xgdb_verbose;
 305
 306 /* gdb prints this when reading a command interactively */
 307 static char *prompt;
 308
 309 /* Buffer used for reading command lines, and the size
 310    allocated for it so far.  */
 311
 312 char *line;
 313 int linesize = 100;
 314
 315 /* Nonzero if the current command is modified by "server ".  This
 316    affects things like recording into the command history, comamnds
 317    repeating on RETURN, etc.  This is so a user interface (emacs, GUI,
 318    whatever) can issue its own commands and also send along commands
 319    from the user, and have the user not notice that the user interface
 320    is issuing commands too.  */
 321 int server_command;
 322
 323 /* Baud rate specified for talking to serial target systems.  Default
 324    is left as -1, so targets can choose their own defaults.  */
 325 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
 326    or (unsigned int)-1.  This is a Bad User Interface.  */
 327
 328 int baud_rate = -1;
 329
 330 /* Timeout limit for response from target. */
 331
 332 int remote_timeout = 20;        /* Set default to 20 */
 333
 334 /* Non-zero tells remote* modules to output debugging info.  */
 335
 336 int remote_debug = 0;
 337
 338 /* Level of control structure.  */
 339 static int control_level;
 340
 341 /* Structure for arguments to user defined functions.  */
 342 #define MAXUSERARGS 10
 343 struct user_args
 344 {
 345   struct user_args *next;
 346   struct
 347     {
 348       char *arg;
 349       int len;
 350     } a[MAXUSERARGS];
 351   int count;
 352 } *user_args;
 353
 354 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT.  */
 355
 356 #ifndef STOP_SIGNAL
 357 #ifdef SIGTSTP
 358 #define STOP_SIGNAL SIGTSTP
 359 static void stop_sig PARAMS ((int));
 360 #endif
 361 #endif
 362
 363 /* Some System V have job control but not sigsetmask(). */
 364 #if !defined (HAVE_SIGSETMASK)
 365 #if !defined (USG)
 366 #define HAVE_SIGSETMASK 1
 367 #else
 368 #define HAVE_SIGSETMASK 0
 369 #endif
 370 #endif
 371
 372 #if 0 == (HAVE_SIGSETMASK)
 373 #define sigsetmask(n)
 374 #endif
 375
 376 /* Hooks for alternate command interfaces.  */
 377
 378 /* Called after most modules have been initialized, but before taking users
 379    command file.  */
 380
 381 void (*init_ui_hook) PARAMS ((char *argv0));
 382 #ifdef __CYGWIN__
 383 void (*ui_loop_hook) PARAMS ((int));
 384 #endif
 385
 386 /* Called instead of command_loop at top level.  Can be invoked via
 387    return_to_top_level.  */
 388
 389 void (*command_loop_hook) PARAMS ((void));
 390
 391
 392 /* Called instead of fputs for all output.  */
 393
 394 void (*fputs_unfiltered_hook) PARAMS ((const char *linebuffer, FILE *stream));
 395
 396 /* Called when the target says something to the host, which may
 397    want to appear in a different window. */
 398
 399 void (*target_output_hook) PARAMS ((char *));
 400
 401 /* Called from print_frame_info to list the line we stopped in.  */
 402
 403 void (*print_frame_info_listing_hook) PARAMS ((struct symtab *s, int line,
 404                                                int stopline, int noerror));
 405 /* Replaces most of query.  */
 406
 407 int (*query_hook) PARAMS ((const char *, va_list));
 408
 409 /* Replaces most of warning.  */
 410
 411 void (*warning_hook) PARAMS ((const char *, va_list));
 412
 413 /* Called from gdb_flush to flush output.  */
 414
 415 void (*flush_hook) PARAMS ((FILE *stream));
 416
 417 /* These three functions support getting lines of text from the user.  They
 418    are used in sequence.  First readline_begin_hook is called with a text
 419    string that might be (for example) a message for the user to type in a
 420    sequence of commands to be executed at a breakpoint.  If this function
 421    calls back to a GUI, it might take this opportunity to pop up a text
 422    interaction window with this message.  Next, readline_hook is called
 423    with a prompt that is emitted prior to collecting the user input.
 424    It can be called multiple times.  Finally, readline_end_hook is called
 425    to notify the GUI that we are done with the interaction window and it
 426    can close it. */
 427
 428 void (*readline_begin_hook) PARAMS ((char *, ...));
 429 char * (*readline_hook) PARAMS ((char *));
 430 void (*readline_end_hook) PARAMS ((void));
 431
 432 /* Called as appropriate to notify the interface of the specified breakpoint
 433    conditions.  */
 434
 435 void (*create_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 436 void (*delete_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 437 void (*modify_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 438
 439 /* Called during long calculations to allow GUI to repair window damage, and to
 440    check for stop buttons, etc... */
 441
 442 void (*interactive_hook) PARAMS ((void));
 443
 444 /* Called when the registers have changed, as a hint to a GUI
 445    to minimize window update. */
 446
 447 void (*registers_changed_hook) PARAMS ((void));
 448
 449 /* tell the GUI someone changed the PC */
 450 void (*pc_changed_hook) PARAMS ((void));
 451
 452 /* Called when going to wait for the target.  Usually allows the GUI to run
 453    while waiting for target events.  */
 454
 455 int (*target_wait_hook) PARAMS ((int pid, struct target_waitstatus *status));
 456
 457 /* Used by UI as a wrapper around command execution.  May do various things
 458    like enabling/disabling buttons, etc...  */
 459
 460 void (*call_command_hook) PARAMS ((struct cmd_list_element *c, char *cmd,
 461                                    int from_tty));
 462
 463 /* Called when the current thread changes.  Argument is thread id.  */
 464
 465 void (*context_hook) PARAMS ((int id));
 466
 467 /* Takes control from error ().  Typically used to prevent longjmps out of the
 468    middle of the GUI.  Usually used in conjunction with a catch routine.  */
 469
 470 NORETURN void (*error_hook) PARAMS ((void)) ATTR_NORETURN;
 471
 472 \f
 473 /* Where to go for return_to_top_level (RETURN_ERROR).  */
 474 SIGJMP_BUF error_return;
 475 /* Where to go for return_to_top_level (RETURN_QUIT).  */
 476 SIGJMP_BUF quit_return;
 477
 478 /* Return for reason REASON.  This generally gets back to the command
 479    loop, but can be caught via catch_errors.  */
 480
 481 NORETURN void
 482 return_to_top_level (reason)
 483      enum return_reason reason;
 484 {
 485   quit_flag = 0;
 486   immediate_quit = 0;
 487
 488   /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
 489      I can think of a reason why that is vital, though).  */
 490   bpstat_clear_actions(stop_bpstat);    /* Clear queued breakpoint commands */
 491
 492   disable_current_display ();
 493   do_cleanups (ALL_CLEANUPS);
 494
 495   if (annotation_level > 1)
 496     switch (reason)
 497       {
 498       case RETURN_QUIT:
 499         annotate_quit ();
 500         break;
 501       case RETURN_ERROR:
 502         annotate_error ();
 503         break;
 504       }
 505
 506   (NORETURN void) SIGLONGJMP
 507     (reason == RETURN_ERROR ? error_return : quit_return, 1);
 508 }
 509
 510 /* Call FUNC with arg ARGS, catching any errors.  If there is no
 511    error, return the value returned by FUNC.  If there is an error,
 512    print ERRSTRING, print the specific error message, then return
 513    zero.
 514
 515    Must not be called with immediate_quit in effect (bad things might
 516    happen, say we got a signal in the middle of a memcpy to quit_return).
 517    This is an OK restriction; with very few exceptions immediate_quit can
 518    be replaced by judicious use of QUIT.
 519
 520    MASK specifies what to catch; it is normally set to
 521    RETURN_MASK_ALL, if for no other reason than that the code which
 522    calls catch_errors might not be set up to deal with a quit which
 523    isn't caught.  But if the code can deal with it, it generally
 524    should be RETURN_MASK_ERROR, unless for some reason it is more
 525    useful to abort only the portion of the operation inside the
 526    catch_errors.  Note that quit should return to the command line
 527    fairly quickly, even if some further processing is being done.  */
 528
 529 int
 530 catch_errors (func, args, errstring, mask)
 531      int (*func) PARAMS ((char *));
 532      PTR args;
 533      char *errstring;
 534      return_mask mask;
 535 {
 536   SIGJMP_BUF saved_error;
 537   SIGJMP_BUF saved_quit;
 538   SIGJMP_BUF tmp_jmp;
 539   int val;
 540   struct cleanup *saved_cleanup_chain;
 541   char *saved_error_pre_print;
 542   char *saved_quit_pre_print;
 543
 544   saved_cleanup_chain = save_cleanups ();
 545   saved_error_pre_print = error_pre_print;
 546   saved_quit_pre_print = quit_pre_print;
 547
 548   if (mask & RETURN_MASK_ERROR)
 549     {
 550       memcpy ((char *)saved_error, (char *)error_return, sizeof (SIGJMP_BUF));
 551       error_pre_print = errstring;
 552     }
 553   if (mask & RETURN_MASK_QUIT)
 554     {
 555       memcpy (saved_quit, quit_return, sizeof (SIGJMP_BUF));
 556       quit_pre_print = errstring;
 557     }
 558
 559   if (SIGSETJMP (tmp_jmp) == 0)
 560     {
 561       if (mask & RETURN_MASK_ERROR)
 562         memcpy (error_return, tmp_jmp, sizeof (SIGJMP_BUF));
 563       if (mask & RETURN_MASK_QUIT)
 564         memcpy (quit_return, tmp_jmp, sizeof (SIGJMP_BUF));
 565       val = (*func) (args);
 566     }
 567   else
 568     val = 0;
 569
 570   restore_cleanups (saved_cleanup_chain);
 571
 572   if (mask & RETURN_MASK_ERROR)
 573     {
 574       memcpy (error_return, saved_error, sizeof (SIGJMP_BUF));
 575       error_pre_print = saved_error_pre_print;
 576     }
 577   if (mask & RETURN_MASK_QUIT)
 578     {
 579       memcpy (quit_return, saved_quit, sizeof (SIGJMP_BUF));
 580       quit_pre_print = saved_quit_pre_print;
 581     }
 582   return val;
 583 }
 584
 585 /* Handler for SIGHUP.  */
 586
 587 #ifdef SIGHUP
 588 static void
 589 disconnect (signo)
 590 int signo;
 591 {
 592   catch_errors (quit_cover, NULL,
 593                 "Could not kill the program being debugged", RETURN_MASK_ALL);
 594   signal (SIGHUP, SIG_DFL);
 595   kill (getpid (), SIGHUP);
 596 }
 597
 598 /* Just a little helper function for disconnect().  */
 599
 600 static int
 601 quit_cover (s)
 602 char *s;
 603 {
 604   caution = 0;          /* Throw caution to the wind -- we're exiting.
 605                            This prevents asking the user dumb questions.  */
 606   quit_command((char *)0, 0);
 607   return 0;
 608 }
 609 #endif /* defined SIGHUP */
 610 \f
 611 /* Line number we are currently in in a file which is being sourced.  */
 612 static int source_line_number;
 613
 614 /* Name of the file we are sourcing.  */
 615 static char *source_file_name;
 616
 617 /* Buffer containing the error_pre_print used by the source stuff.
 618    Malloc'd.  */
 619 static char *source_error;
 620 static int source_error_allocated;
 621
 622 /* Something to glom on to the start of error_pre_print if source_file_name
 623    is set.  */
 624 static char *source_pre_error;
 625
 626 /* Clean up on error during a "source" command (or execution of a
 627    user-defined command).  */
 628
 629 static void
 630 source_cleanup (stream)
 631      FILE *stream;
 632 {
 633   /* Restore the previous input stream.  */
 634   instream = stream;
 635 }
 636
 637 /* Read commands from STREAM.  */
 638 void
 639 read_command_file (stream)
 640      FILE *stream;
 641 {
 642   struct cleanup *cleanups;
 643
 644   cleanups = make_cleanup ((make_cleanup_func) source_cleanup, instream);
 645   instream = stream;
 646   command_loop ();
 647   do_cleanups (cleanups);
 648 }
 649 \f
 650 extern void init_proc PARAMS ((void));
 651
 652 void (*pre_init_ui_hook) PARAMS ((void));
 653
 654 void
 655 gdb_init (argv0)
 656      char *argv0;
 657 {
 658   if (pre_init_ui_hook)
 659     pre_init_ui_hook ();
 660
 661   /* Run the init function of each source file */
 662
 663   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 664   current_directory = gdb_dirbuf;
 665
 666   init_cmd_lists ();    /* This needs to be done first */
 667   initialize_targets (); /* Setup target_terminal macros for utils.c */
 668   initialize_utils ();  /* Make errors and warnings possible */
 669   initialize_all_files ();
 670   init_main ();         /* But that omits this file!  Do it now */
 671   init_signals ();
 672
 673   init_proc ();
 674
 675   /* We need a default language for parsing expressions, so simple things like
 676      "set width 0" won't fail if no language is explicitly set in a config file
 677      or implicitly set by reading an executable during startup. */
 678   set_language (language_c);
 679   expected_language = current_language; /* don't warn about the change.  */
 680
 681   if (init_ui_hook)
 682     init_ui_hook (argv0);
 683 }
 684
 685 /* Allocate, initialize a new command line structure for one of the
 686    control commands (if/while).  */
 687
 688 static struct command_line *
 689 build_command_line (type, args)
 690      enum command_control_type type;
 691      char *args;
 692 {
 693   struct command_line *cmd;
 694
 695   if (args == NULL)
 696     error ("if/while commands require arguments.\n");
 697
 698   cmd = (struct command_line *)xmalloc (sizeof (struct command_line));
 699   cmd->next = NULL;
 700   cmd->control_type = type;
 701
 702   cmd->body_count = 1;
 703   cmd->body_list
 704     = (struct command_line **)xmalloc (sizeof (struct command_line *)
 705                                        * cmd->body_count);
 706   memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
 707   cmd->line = savestring (args, strlen (args));
 708   return cmd;
 709 }
 710
 711 /* Build and return a new command structure for the control commands
 712    such as "if" and "while".  */
 713
 714 static struct command_line *
 715 get_command_line (type, arg)
 716      enum command_control_type type;
 717      char *arg;
 718 {
 719   struct command_line *cmd;
 720   struct cleanup *old_chain = NULL;
 721
 722   /* Allocate and build a new command line structure.  */
 723   cmd = build_command_line (type, arg);
 724
 725   old_chain = make_cleanup ((make_cleanup_func) free_command_lines, &cmd);
 726
 727   /* Read in the body of this command.  */
 728   if (recurse_read_control_structure (cmd) == invalid_control)
 729     {
 730       warning ("error reading in control structure\n");
 731       do_cleanups (old_chain);
 732       return NULL;
 733     }
 734
 735   discard_cleanups (old_chain);
 736   return cmd;
 737 }
 738
 739 /* Recursively print a command (including full control structures).  */
 740 void
 741 print_command_line (cmd, depth)
 742      struct command_line *cmd;
 743      unsigned int depth;
 744 {
 745   unsigned int i;
 746
 747   if (depth)
 748     {
 749       for (i = 0; i < depth; i++)
 750         fputs_filtered ("  ", gdb_stdout);
 751     }
 752
 753   /* A simple command, print it and return.  */
 754   if (cmd->control_type == simple_control)
 755     {
 756       fputs_filtered (cmd->line, gdb_stdout);
 757       fputs_filtered ("\n", gdb_stdout);
 758       return;
 759     }
 760
 761   /* loop_continue to jump to the start of a while loop, print it
 762      and return. */
 763   if (cmd->control_type == continue_control)
 764     {
 765       fputs_filtered ("loop_continue\n", gdb_stdout);
 766       return;
 767     }
 768
 769   /* loop_break to break out of a while loop, print it and return.  */
 770   if (cmd->control_type == break_control)
 771     {
 772       fputs_filtered ("loop_break\n", gdb_stdout);
 773       return;
 774     }
 775
 776   /* A while command.  Recursively print its subcommands before returning.  */
 777   if (cmd->control_type == while_control)
 778     {
 779       struct command_line *list;
 780       fputs_filtered ("while ", gdb_stdout);
 781       fputs_filtered (cmd->line, gdb_stdout);
 782       fputs_filtered ("\n", gdb_stdout);
 783       list = *cmd->body_list;
 784       while (list)
 785         {
 786           print_command_line (list, depth + 1);
 787           list = list->next;
 788         }
 789     }
 790
 791   /* An if command.  Recursively print both arms before returning.  */
 792   if (cmd->control_type == if_control)
 793     {
 794       fputs_filtered ("if ", gdb_stdout);
 795       fputs_filtered (cmd->line, gdb_stdout);
 796       fputs_filtered ("\n", gdb_stdout);
 797       /* The true arm. */
 798       print_command_line (cmd->body_list[0], depth + 1);
 799
 800       /* Show the false arm if it exists.  */
 801       if (cmd->body_count == 2)
 802           {
 803             if (depth)
 804               {
 805                 for (i = 0; i < depth; i++)
 806                   fputs_filtered ("  ", gdb_stdout);
 807               }
 808             fputs_filtered ("else\n", gdb_stdout);
 809             print_command_line (cmd->body_list[1], depth + 1);
 810           }
 811       if (depth)
 812         {
 813           for (i = 0; i < depth; i++)
 814             fputs_filtered ("  ", gdb_stdout);
 815         }
 816       fputs_filtered ("end\n", gdb_stdout);
 817     }
 818 }
 819
 820 /* Execute the command in CMD.  */
 821
 822 enum command_control_type
 823 execute_control_command (cmd)
 824      struct command_line *cmd;
 825 {
 826   struct expression *expr;
 827   struct command_line *current;
 828   struct cleanup *old_chain = 0;
 829   value_ptr val;
 830   value_ptr val_mark;
 831   int loop;
 832   enum command_control_type ret;
 833   char *new_line;
 834
 835   switch (cmd->control_type)
 836     {
 837     case simple_control:
 838       /* A simple command, execute it and return.  */
 839       new_line = insert_args (cmd->line);
 840       if (!new_line)
 841         return invalid_control;
 842       old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
 843                                 &new_line);
 844       execute_command (new_line, 0);
 845       ret = cmd->control_type;
 846       break;
 847
 848     case continue_control:
 849     case break_control:
 850       /* Return for "continue", and "break" so we can either
 851          continue the loop at the top, or break out.  */
 852       ret = cmd->control_type;
 853       break;
 854
 855     case while_control:
 856       {
 857         /* Parse the loop control expression for the while statement.  */
 858         new_line = insert_args (cmd->line);
 859         if (!new_line)
 860           return invalid_control;
 861         old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
 862                                   &new_line);
 863         expr = parse_expression (new_line);
 864         make_cleanup ((make_cleanup_func) free_current_contents, &expr);
 865
 866         ret = simple_control;
 867         loop = 1;
 868
 869         /* Keep iterating so long as the expression is true.  */
 870         while (loop == 1)
 871           {
 872             int cond_result;
 873
 874             QUIT;
 875
 876             /* Evaluate the expression.  */
 877             val_mark = value_mark ();
 878             val = evaluate_expression (expr);
 879             cond_result = value_true (val);
 880             value_free_to_mark (val_mark);
 881
 882             /* If the value is false, then break out of the loop.  */
 883             if (!cond_result)
 884               break;
 885
 886             /* Execute the body of the while statement.  */
 887             current = *cmd->body_list;
 888             while (current)
 889               {
 890                 ret = execute_control_command (current);
 891
 892                 /* If we got an error, or a "break" command, then stop
 893                    looping.  */
 894                 if (ret == invalid_control || ret == break_control)
 895                   {
 896                     loop = 0;
 897                     break;
 898                   }
 899
 900                 /* If we got a "continue" command, then restart the loop
 901                    at this point.  */
 902                 if (ret == continue_control)
 903                   break;
 904
 905                 /* Get the next statement.  */
 906                 current = current->next;
 907               }
 908           }
 909
 910         /* Reset RET so that we don't recurse the break all the way down.  */
 911         if (ret == break_control)
 912           ret = simple_control;
 913
 914         break;
 915       }
 916
 917     case if_control:
 918       {
 919         new_line = insert_args (cmd->line);
 920         if (!new_line)
 921           return invalid_control;
 922         old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
 923                                   &new_line);
 924         /* Parse the conditional for the if statement.  */
 925         expr = parse_expression (new_line);
 926         make_cleanup ((make_cleanup_func) free_current_contents, &expr);
 927
 928         current = NULL;
 929         ret = simple_control;
 930
 931         /* Evaluate the conditional.  */
 932         val_mark = value_mark ();
 933         val = evaluate_expression (expr);
 934
 935         /* Choose which arm to take commands from based on the value of the
 936            conditional expression.  */
 937         if (value_true (val))
 938           current = *cmd->body_list;
 939         else if (cmd->body_count == 2)
 940           current = *(cmd->body_list + 1);
 941         value_free_to_mark (val_mark);
 942
 943         /* Execute commands in the given arm.  */
 944         while (current)
 945           {
 946             ret = execute_control_command (current);
 947
 948             /* If we got an error, get out.  */
 949             if (ret != simple_control)
 950               break;
 951
 952             /* Get the next statement in the body.  */
 953             current = current->next;
 954           }
 955
 956         break;
 957       }
 958
 959     default:
 960       warning ("Invalid control type in command structure.");
 961       return invalid_control;
 962     }
 963
 964   if (old_chain)
 965     do_cleanups (old_chain);
 966
 967   return ret;
 968 }
 969
 970 /* "while" command support.  Executes a body of statements while the
 971    loop condition is nonzero.  */
 972
 973 static void
 974 while_command (arg, from_tty)
 975      char *arg;
 976      int from_tty;
 977 {
 978   struct command_line *command = NULL;
 979
 980   control_level = 1;
 981   command = get_command_line (while_control, arg);
 982
 983   if (command == NULL)
 984     return;
 985
 986   execute_control_command (command);
 987   free_command_lines (&command);
 988 }
 989
 990 /* "if" command support.  Execute either the true or false arm depending
 991    on the value of the if conditional.  */
 992
 993 static void
 994 if_command (arg, from_tty)
 995      char *arg;
 996      int from_tty;
 997 {
 998   struct command_line *command = NULL;
 999
1000   control_level = 1;
1001   command = get_command_line (if_control, arg);
1002
1003   if (command == NULL)
1004     return;
1005
1006   execute_control_command (command);
1007   free_command_lines (&command);
1008 }
1009
1010 /* Cleanup */
1011 static void
1012 arg_cleanup ()
1013 {
1014   struct user_args *oargs = user_args;
1015   if (!user_args)
1016     fatal ("Internal error, arg_cleanup called with no user args.\n");
1017
1018   user_args = user_args->next;
1019   free (oargs);
1020 }
1021
1022 /* Bind the incomming arguments for a user defined command to
1023    $arg0, $arg1 ... $argMAXUSERARGS.  */
1024
1025 static struct cleanup *
1026 setup_user_args (p)
1027      char *p;
1028 {
1029   struct user_args *args;
1030   struct cleanup *old_chain;
1031   unsigned int arg_count = 0;
1032
1033   args = (struct user_args *)xmalloc (sizeof (struct user_args));
1034   memset (args, 0, sizeof (struct user_args));
1035
1036   args->next = user_args;
1037   user_args = args;
1038
1039   old_chain = make_cleanup ((make_cleanup_func) arg_cleanup, 0);
1040
1041   if (p == NULL)
1042     return old_chain;
1043
1044   while (*p)
1045     {
1046       char *start_arg;
1047       int squote = 0;
1048       int dquote = 0;
1049       int bsquote = 0;
1050
1051       if (arg_count >= MAXUSERARGS)
1052         {
1053           error ("user defined function may only have %d arguments.\n",
1054                  MAXUSERARGS);
1055           return old_chain;
1056         }
1057
1058       /* Strip whitespace.  */
1059       while (*p == ' ' || *p == '\t')
1060         p++;
1061
1062       /* P now points to an argument.  */
1063       start_arg = p;
1064       user_args->a[arg_count].arg = p;
1065
1066       /* Get to the end of this argument.  */
1067       while (*p)
1068         {
1069           if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
1070             break;
1071           else
1072             {
1073               if (bsquote)
1074                 bsquote = 0;
1075               else if (*p == '\\')
1076                 bsquote = 1;
1077               else if (squote)
1078                 {
1079                   if (*p == '\'')
1080                     squote = 0;
1081                 }
1082               else if (dquote)
1083                 {
1084                   if (*p == '"')
1085                     dquote = 0;
1086                 }
1087               else
1088                 {
1089                   if (*p == '\'')
1090                     squote = 1;
1091                   else if (*p == '"')
1092                     dquote = 1;
1093                 }
1094               p++;
1095             }
1096         }
1097
1098       user_args->a[arg_count].len = p - start_arg;
1099       arg_count++;
1100       user_args->count++;
1101     }
1102   return old_chain;
1103 }
1104
1105 /* Given character string P, return a point to the first argument ($arg),
1106    or NULL if P contains no arguments.  */
1107
1108 static char *
1109 locate_arg (p)
1110      char *p;
1111 {
1112   while ((p = strchr (p, '$')))
1113     {
1114       if (strncmp (p, "$arg", 4) == 0 && isdigit (p[4]))
1115         return p;
1116       p++;
1117     }
1118   return NULL;
1119 }
1120
1121 /* Insert the user defined arguments stored in user_arg into the $arg
1122    arguments found in line, with the updated copy being placed into nline.  */
1123
1124 static char *
1125 insert_args (line)
1126      char *line;
1127 {
1128   char *p, *save_line, *new_line;
1129   unsigned len, i;
1130
1131   /* First we need to know how much memory to allocate for the new line.  */
1132   save_line = line;
1133   len = 0;
1134   while ((p = locate_arg (line)))
1135     {
1136       len += p - line;
1137       i = p[4] - '0';
1138
1139       if (i >= user_args->count)
1140         {
1141           error ("Missing argument %d in user function.\n", i);
1142           return NULL;
1143         }
1144       len += user_args->a[i].len;
1145       line = p + 5;
1146     }
1147
1148   /* Don't forget the tail.  */
1149   len += strlen (line);
1150
1151   /* Allocate space for the new line and fill it in.  */
1152   new_line = (char *)xmalloc (len + 1);
1153   if (new_line == NULL)
1154     return NULL;
1155
1156   /* Restore pointer to beginning of old line.  */
1157   line = save_line;
1158
1159   /* Save pointer to beginning of new line.  */
1160   save_line = new_line;
1161
1162   while ((p = locate_arg (line)))
1163     {
1164       int i, len;
1165
1166       memcpy (new_line, line, p - line);
1167       new_line += p - line;
1168       i = p[4] - '0';
1169
1170       len = user_args->a[i].len;
1171       if (len)
1172         {
1173           memcpy (new_line, user_args->a[i].arg, len);
1174           new_line += len;
1175         }
1176       line = p + 5;
1177     }
1178   /* Don't forget the tail.  */
1179   strcpy (new_line, line);
1180
1181   /* Return a pointer to the beginning of the new line.  */
1182   return save_line;
1183 }
1184
1185 void
1186 execute_user_command (c, args)
1187      struct cmd_list_element *c;
1188      char *args;
1189 {
1190   register struct command_line *cmdlines;
1191   struct cleanup *old_chain;
1192   enum command_control_type ret;
1193
1194   old_chain = setup_user_args (args);
1195
1196   cmdlines = c->user_commands;
1197   if (cmdlines == 0)
1198     /* Null command */
1199     return;
1200
1201   /* Set the instream to 0, indicating execution of a
1202      user-defined function.  */
1203   old_chain = make_cleanup ((make_cleanup_func) source_cleanup, instream);
1204   instream = (FILE *) 0;
1205   while (cmdlines)
1206     {
1207       ret = execute_control_command (cmdlines);
1208       if (ret != simple_control && ret != break_control)
1209         {
1210           warning ("Error in control structure.\n");
1211           break;
1212         }
1213       cmdlines = cmdlines->next;
1214     }
1215   do_cleanups (old_chain);
1216 }
1217
1218 /* Execute the line P as a command.
1219    Pass FROM_TTY as second argument to the defining function.  */
1220
1221 void
1222 execute_command (p, from_tty)
1223      char *p;
1224      int from_tty;
1225 {
1226   register struct cmd_list_element *c;
1227   register enum language flang;
1228   static int warned = 0;
1229   /* FIXME: These should really be in an appropriate header file */
1230   extern void serial_log_command PARAMS ((const char *));
1231
1232   free_all_values ();
1233
1234   /* Force cleanup of any alloca areas if using C alloca instead of
1235      a builtin alloca.  */
1236   alloca (0);
1237
1238   /* This can happen when command_line_input hits end of file.  */
1239   if (p == NULL)
1240       return;
1241
1242   serial_log_command (p);
1243
1244   while (*p == ' ' || *p == '\t') p++;
1245   if (*p)
1246     {
1247       char *arg;
1248
1249       c = lookup_cmd (&p, cmdlist, "", 0, 1);
1250       /* Pass null arg rather than an empty one.  */
1251       arg = *p ? p : 0;
1252
1253       /* Clear off trailing whitespace, except for set and complete command.  */
1254       if (arg && c->type != set_cmd && c->function.cfunc != complete_command)
1255         {
1256           p = arg + strlen (arg) - 1;
1257           while (p >= arg && (*p == ' ' || *p == '\t'))
1258             p--;
1259           *(p + 1) = '\0';
1260         }
1261
1262       /* If this command has been hooked, run the hook first. */
1263       if (c->hook)
1264         execute_user_command (c->hook, (char *)0);
1265
1266       if (c->class == class_user)
1267         execute_user_command (c, arg);
1268       else if (c->type == set_cmd || c->type == show_cmd)
1269         do_setshow_command (arg, from_tty & caution, c);
1270       else if (c->function.cfunc == NO_FUNCTION)
1271         error ("That is not a command, just a help topic.");
1272       else if (call_command_hook)
1273         call_command_hook (c, arg, from_tty & caution);
1274       else
1275         (*c->function.cfunc) (arg, from_tty & caution);
1276    }
1277
1278   /* Tell the user if the language has changed (except first time).  */
1279   if (current_language != expected_language)
1280   {
1281     if (language_mode == language_mode_auto) {
1282       language_info (1);        /* Print what changed.  */
1283     }
1284     warned = 0;
1285   }
1286
1287   /* Warn the user if the working language does not match the
1288      language of the current frame.  Only warn the user if we are
1289      actually running the program, i.e. there is a stack. */
1290   /* FIXME:  This should be cacheing the frame and only running when
1291      the frame changes.  */
1292
1293   if (target_has_stack)
1294     {
1295       flang = get_frame_language ();
1296       if (!warned
1297           && flang != language_unknown
1298           && flang != current_language->la_language)
1299         {
1300           printf_filtered ("%s\n", lang_frame_mismatch_warn);
1301           warned = 1;
1302         }
1303     }
1304 }
1305
1306 /* ARGSUSED */
1307 static void
1308 command_loop_marker (foo)
1309      int foo;
1310 {
1311 }
1312
1313 /* Read commands from `instream' and execute them
1314    until end of file or error reading instream.  */
1315
1316 void
1317 command_loop ()
1318 {
1319   struct cleanup *old_chain;
1320   char *command;
1321   int stdin_is_tty = ISATTY (stdin);
1322   long time_at_cmd_start;
1323 #ifdef HAVE_SBRK
1324   long space_at_cmd_start;
1325 #endif
1326   extern int display_time;
1327   extern int display_space;
1328
1329   while (instream && !feof (instream))
1330     {
1331       if (window_hook && instream == stdin)
1332         (*window_hook) (instream, prompt);
1333
1334       quit_flag = 0;
1335       if (instream == stdin && stdin_is_tty)
1336         reinitialize_more_filter ();
1337       old_chain = make_cleanup ((make_cleanup_func) command_loop_marker, 0);
1338       command = command_line_input (instream == stdin ? prompt : (char *) NULL,
1339                                     instream == stdin, "prompt");
1340       if (command == 0)
1341         return;
1342
1343       time_at_cmd_start = get_run_time ();
1344
1345       if (display_space)
1346         {
1347 #ifdef HAVE_SBRK
1348           extern char **environ;
1349           char *lim = (char *) sbrk (0);
1350
1351           space_at_cmd_start = (long) (lim - (char *) &environ);
1352 #endif
1353         }
1354
1355       execute_command (command, instream == stdin);
1356       /* Do any commands attached to breakpoint we stopped at.  */
1357       bpstat_do_actions (&stop_bpstat);
1358       do_cleanups (old_chain);
1359
1360       if (display_time)
1361         {
1362           long cmd_time = get_run_time () - time_at_cmd_start;
1363
1364           printf_unfiltered ("Command execution time: %ld.%06ld\n",
1365                              cmd_time / 1000000, cmd_time % 1000000);
1366         }
1367
1368       if (display_space)
1369         {
1370 #ifdef HAVE_SBRK
1371           extern char **environ;
1372           char *lim = (char *) sbrk (0);
1373           long space_now = lim - (char *) &environ;
1374           long space_diff = space_now - space_at_cmd_start;
1375
1376           printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
1377                              space_now,
1378                              (space_diff >= 0 ? '+' : '-'),
1379                              space_diff);
1380 #endif
1381         }
1382     }
1383 }
1384 \f
1385 /* Commands call this if they do not want to be repeated by null lines.  */
1386
1387 void
1388 dont_repeat ()
1389 {
1390   if (server_command)
1391     return;
1392
1393   /* If we aren't reading from standard input, we are saving the last
1394      thing read from stdin in line and don't want to delete it.  Null lines
1395      won't repeat here in any case.  */
1396   if (instream == stdin)
1397     *line = 0;
1398 }
1399 \f
1400 /* Read a line from the stream "instream" without command line editing.
1401
1402    It prints PRROMPT once at the start.
1403    Action is compatible with "readline", e.g. space for the result is
1404    malloc'd and should be freed by the caller.
1405
1406    A NULL return means end of file.  */
1407 char *
1408 gdb_readline (prrompt)
1409      char *prrompt;
1410 {
1411   int c;
1412   char *result;
1413   int input_index = 0;
1414   int result_size = 80;
1415
1416   if (prrompt)
1417     {
1418       /* Don't use a _filtered function here.  It causes the assumed
1419          character position to be off, since the newline we read from
1420          the user is not accounted for.  */
1421       fputs_unfiltered (prrompt, gdb_stdout);
1422 #ifdef MPW
1423       /* Move to a new line so the entered line doesn't have a prompt
1424          on the front of it. */
1425       fputs_unfiltered ("\n", gdb_stdout);
1426 #endif /* MPW */
1427       gdb_flush (gdb_stdout);
1428     }
1429
1430   result = (char *) xmalloc (result_size);
1431
1432   while (1)
1433     {
1434       /* Read from stdin if we are executing a user defined command.
1435          This is the right thing for prompt_for_continue, at least.  */
1436       c = fgetc (instream ? instream : stdin);
1437
1438       if (c == EOF)
1439         {
1440           if (input_index > 0)
1441             /* The last line does not end with a newline.  Return it, and
1442                if we are called again fgetc will still return EOF and
1443                we'll return NULL then.  */
1444             break;
1445           free (result);
1446           return NULL;
1447         }
1448
1449       if (c == '\n')
1450 #ifndef CRLF_SOURCE_FILES
1451         break;
1452 #else
1453         {
1454           if (input_index > 0 && result[input_index - 1] == '\r')
1455             input_index--;
1456           break;
1457         }
1458 #endif
1459
1460       result[input_index++] = c;
1461       while (input_index >= result_size)
1462         {
1463           result_size *= 2;
1464           result = (char *) xrealloc (result, result_size);
1465         }
1466     }
1467
1468   result[input_index++] = '\0';
1469   return result;
1470 }
1471
1472 /* Variables which control command line editing and history
1473    substitution.  These variables are given default values at the end
1474    of this file.  */
1475 static int command_editing_p;
1476 static int history_expansion_p;
1477 static int write_history_p;
1478 static int history_size;
1479 static char *history_filename;
1480
1481 /* readline uses the word breaks for two things:
1482    (1) In figuring out where to point the TEXT parameter to the
1483    rl_completion_entry_function.  Since we don't use TEXT for much,
1484    it doesn't matter a lot what the word breaks are for this purpose, but
1485    it does affect how much stuff M-? lists.
1486    (2) If one of the matches contains a word break character, readline
1487    will quote it.  That's why we switch between
1488    gdb_completer_word_break_characters and
1489    gdb_completer_command_word_break_characters.  I'm not sure when
1490    we need this behavior (perhaps for funky characters in C++ symbols?).  */
1491
1492 /* Variables which are necessary for fancy command line editing.  */
1493 char *gdb_completer_word_break_characters =
1494   " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1495
1496 /* When completing on command names, we remove '-' from the list of
1497    word break characters, since we use it in command names.  If the
1498    readline library sees one in any of the current completion strings,
1499    it thinks that the string needs to be quoted and automatically supplies
1500    a leading quote. */
1501 char *gdb_completer_command_word_break_characters =
1502   " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
1503
1504 /* Characters that can be used to quote completion strings.  Note that we
1505    can't include '"' because the gdb C parser treats such quoted sequences
1506    as strings. */
1507 char *gdb_completer_quote_characters =
1508   "'";
1509
1510 /* Functions that are used as part of the fancy command line editing.  */
1511
1512 /* This can be used for functions which don't want to complete on symbols
1513    but don't want to complete on anything else either.  */
1514 /* ARGSUSED */
1515 char **
1516 noop_completer (text, prefix)
1517      char *text;
1518      char *prefix;
1519 {
1520   return NULL;
1521 }
1522
1523 /* Complete on filenames.  */
1524 char **
1525 filename_completer (text, word)
1526      char *text;
1527      char *word;
1528 {
1529   /* From readline.  */
1530   extern char *filename_completion_function PARAMS ((char *, int));
1531   int subsequent_name;
1532   char **return_val;
1533   int return_val_used;
1534   int return_val_alloced;
1535
1536   return_val_used = 0;
1537   /* Small for testing.  */
1538   return_val_alloced = 1;
1539   return_val = (char **) xmalloc (return_val_alloced * sizeof (char *));
1540
1541   subsequent_name = 0;
1542   while (1)
1543     {
1544       char *p;
1545       p = filename_completion_function (text, subsequent_name);
1546       if (return_val_used >= return_val_alloced)
1547         {
1548           return_val_alloced *= 2;
1549           return_val =
1550             (char **) xrealloc (return_val,
1551                                 return_val_alloced * sizeof (char *));
1552         }
1553       if (p == NULL)
1554         {
1555           return_val[return_val_used++] = p;
1556           break;
1557         }
1558       /* Like emacs, don't complete on old versions.  Especially useful
1559          in the "source" command.  */
1560       if (p[strlen (p) - 1] == '~')
1561         continue;
1562
1563       {
1564         char *q;
1565         if (word == text)
1566           /* Return exactly p.  */
1567           return_val[return_val_used++] = p;
1568         else if (word > text)
1569           {
1570             /* Return some portion of p.  */
1571             q = xmalloc (strlen (p) + 5);
1572             strcpy (q, p + (word - text));
1573             return_val[return_val_used++] = q;
1574             free (p);
1575           }
1576         else
1577           {
1578             /* Return some of TEXT plus p.  */
1579             q = xmalloc (strlen (p) + (text - word) + 5);
1580             strncpy (q, word, text - word);
1581             q[text - word] = '\0';
1582             strcat (q, p);
1583             return_val[return_val_used++] = q;
1584             free (p);
1585           }
1586       }
1587       subsequent_name = 1;
1588     }
1589 #if 0
1590   /* There is no way to do this just long enough to affect quote inserting
1591      without also affecting the next completion.  This should be fixed in
1592      readline.  FIXME.  */
1593   /* Insure that readline does the right thing
1594      with respect to inserting quotes.  */
1595   rl_completer_word_break_characters = "";
1596 #endif
1597   return return_val;
1598 }
1599
1600 /* Here are some useful test cases for completion.  FIXME: These should
1601    be put in the test suite.  They should be tested with both M-? and TAB.
1602
1603    "show output-" "radix"
1604    "show output" "-radix"
1605    "p" ambiguous (commands starting with p--path, print, printf, etc.)
1606    "p "  ambiguous (all symbols)
1607    "info t foo" no completions
1608    "info t " no completions
1609    "info t" ambiguous ("info target", "info terminal", etc.)
1610    "info ajksdlfk" no completions
1611    "info ajksdlfk " no completions
1612    "info" " "
1613    "info " ambiguous (all info commands)
1614    "p \"a" no completions (string constant)
1615    "p 'a" ambiguous (all symbols starting with a)
1616    "p b-a" ambiguous (all symbols starting with a)
1617    "p b-" ambiguous (all symbols)
1618    "file Make" "file" (word break hard to screw up here)
1619    "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1620    */
1621
1622 /* Generate completions one by one for the completer.  Each time we are
1623    called return another potential completion to the caller.
1624    line_completion just completes on commands or passes the buck to the
1625    command's completer function, the stuff specific to symbol completion
1626    is in make_symbol_completion_list.
1627
1628    TEXT is the caller's idea of the "word" we are looking at.
1629
1630    MATCHES is the number of matches that have currently been collected from
1631    calling this completion function.  When zero, then we need to initialize,
1632    otherwise the initialization has already taken place and we can just
1633    return the next potential completion string.
1634
1635    LINE_BUFFER is available to be looked at; it contains the entire text
1636    of the line.  POINT is the offset in that line of the cursor.  You
1637    should pretend that the line ends at POINT.
1638
1639    Returns NULL if there are no more completions, else a pointer to a string
1640    which is a possible completion, it is the caller's responsibility to
1641    free the string.  */
1642
1643 static char *
1644 line_completion_function (text, matches, line_buffer, point)
1645      char *text;
1646      int matches;
1647      char *line_buffer;
1648      int point;
1649 {
1650   static char **list = (char **)NULL;           /* Cache of completions */
1651   static int index;                             /* Next cached completion */
1652   char *output = NULL;
1653   char *tmp_command, *p;
1654   /* Pointer within tmp_command which corresponds to text.  */
1655   char *word;
1656   struct cmd_list_element *c, *result_list;
1657
1658   if (matches == 0)
1659     {
1660       /* The caller is beginning to accumulate a new set of completions, so
1661          we need to find all of them now, and cache them for returning one at
1662          a time on future calls. */
1663
1664       if (list)
1665         {
1666           /* Free the storage used by LIST, but not by the strings inside.
1667              This is because rl_complete_internal () frees the strings. */
1668           free ((PTR)list);
1669         }
1670       list = 0;
1671       index = 0;
1672
1673       /* Choose the default set of word break characters to break completions.
1674          If we later find out that we are doing completions on command strings
1675          (as opposed to strings supplied by the individual command completer
1676          functions, which can be any string) then we will switch to the
1677          special word break set for command strings, which leaves out the
1678          '-' character used in some commands.  */
1679
1680       rl_completer_word_break_characters =
1681           gdb_completer_word_break_characters;
1682
1683       /* Decide whether to complete on a list of gdb commands or on symbols. */
1684       tmp_command = (char *) alloca (point + 1);
1685       p = tmp_command;
1686
1687       strncpy (tmp_command, line_buffer, point);
1688       tmp_command[point] = '\0';
1689       /* Since text always contains some number of characters leading up
1690          to point, we can find the equivalent position in tmp_command
1691          by subtracting that many characters from the end of tmp_command.  */
1692       word = tmp_command + point - strlen (text);
1693
1694       if (point == 0)
1695         {
1696           /* An empty line we want to consider ambiguous; that is, it
1697              could be any command.  */
1698           c = (struct cmd_list_element *) -1;
1699           result_list = 0;
1700         }
1701       else
1702         {
1703           c = lookup_cmd_1 (&p, cmdlist, &result_list, 1);
1704         }
1705
1706       /* Move p up to the next interesting thing.  */
1707       while (*p == ' ' || *p == '\t')
1708         {
1709           p++;
1710         }
1711
1712       if (!c)
1713         {
1714           /* It is an unrecognized command.  So there are no
1715              possible completions.  */
1716           list = NULL;
1717         }
1718       else if (c == (struct cmd_list_element *) -1)
1719         {
1720           char *q;
1721
1722           /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1723              doesn't advance over that thing itself.  Do so now.  */
1724           q = p;
1725           while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
1726             ++q;
1727           if (q != tmp_command + point)
1728             {
1729               /* There is something beyond the ambiguous
1730                  command, so there are no possible completions.  For
1731                  example, "info t " or "info t foo" does not complete
1732                  to anything, because "info t" can be "info target" or
1733                  "info terminal".  */
1734               list = NULL;
1735             }
1736           else
1737             {
1738               /* We're trying to complete on the command which was ambiguous.
1739                  This we can deal with.  */
1740               if (result_list)
1741                 {
1742                   list = complete_on_cmdlist (*result_list->prefixlist, p,
1743                                               word);
1744                 }
1745               else
1746                 {
1747                   list = complete_on_cmdlist (cmdlist, p, word);
1748                 }
1749               /* Insure that readline does the right thing with respect to
1750                  inserting quotes.  */
1751               rl_completer_word_break_characters =
1752                 gdb_completer_command_word_break_characters;
1753             }
1754         }
1755       else
1756         {
1757           /* We've recognized a full command.  */
1758
1759           if (p == tmp_command + point)
1760             {
1761               /* There is no non-whitespace in the line beyond the command.  */
1762
1763               if (p[-1] == ' ' || p[-1] == '\t')
1764                 {
1765                   /* The command is followed by whitespace; we need to complete
1766                      on whatever comes after command.  */
1767                   if (c->prefixlist)
1768                     {
1769                       /* It is a prefix command; what comes after it is
1770                          a subcommand (e.g. "info ").  */
1771                       list = complete_on_cmdlist (*c->prefixlist, p, word);
1772
1773                       /* Insure that readline does the right thing
1774                          with respect to inserting quotes.  */
1775                       rl_completer_word_break_characters =
1776                         gdb_completer_command_word_break_characters;
1777                     }
1778                   else if (c->enums)
1779                     {
1780                       list = complete_on_enum (c->enums, p, word);
1781                       rl_completer_word_break_characters =
1782                         gdb_completer_command_word_break_characters;
1783                     }
1784                   else
1785                     {
1786                       /* It is a normal command; what comes after it is
1787                          completed by the command's completer function.  */
1788                       list = (*c->completer) (p, word);
1789                     }
1790                 }
1791               else
1792                 {
1793                   /* The command is not followed by whitespace; we need to
1794                      complete on the command itself.  e.g. "p" which is a
1795                      command itself but also can complete to "print", "ptype"
1796                      etc.  */
1797                   char *q;
1798
1799                   /* Find the command we are completing on.  */
1800                   q = p;
1801                   while (q > tmp_command)
1802                     {
1803                       if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
1804                         --q;
1805                       else
1806                         break;
1807                     }
1808
1809                   list = complete_on_cmdlist (result_list, q, word);
1810
1811                   /* Insure that readline does the right thing
1812                      with respect to inserting quotes.  */
1813                   rl_completer_word_break_characters =
1814                     gdb_completer_command_word_break_characters;
1815                 }
1816             }
1817           else
1818             {
1819               /* There is non-whitespace beyond the command.  */
1820
1821               if (c->prefixlist && !c->allow_unknown)
1822                 {
1823                   /* It is an unrecognized subcommand of a prefix command,
1824                      e.g. "info adsfkdj".  */
1825                   list = NULL;
1826                 }
1827               else if (c->enums)
1828                 {
1829                   list = complete_on_enum (c->enums, p, word);
1830                 }
1831               else
1832                 {
1833                   /* It is a normal command.  */
1834                   list = (*c->completer) (p, word);
1835                 }
1836             }
1837         }
1838     }
1839
1840   /* If we found a list of potential completions during initialization then
1841      dole them out one at a time.  The vector of completions is NULL
1842      terminated, so after returning the last one, return NULL (and continue
1843      to do so) each time we are called after that, until a new list is
1844      available. */
1845
1846   if (list)
1847     {
1848       output = list[index];
1849       if (output)
1850         {
1851           index++;
1852         }
1853     }
1854
1855 #if 0
1856   /* Can't do this because readline hasn't yet checked the word breaks
1857      for figuring out whether to insert a quote.  */
1858   if (output == NULL)
1859     /* Make sure the word break characters are set back to normal for the
1860        next time that readline tries to complete something.  */
1861     rl_completer_word_break_characters =
1862       gdb_completer_word_break_characters;
1863 #endif
1864
1865   return (output);
1866 }
1867
1868 /* Line completion interface function for readline.  */
1869
1870 static char *
1871 readline_line_completion_function (text, matches)
1872      char *text;
1873      int matches;
1874 {
1875   return line_completion_function (text, matches, rl_line_buffer, rl_point);
1876 }
1877
1878 /* Skip over a possibly quoted word (as defined by the quote characters
1879    and word break characters the completer uses).  Returns pointer to the
1880    location after the "word". */
1881
1882 char *
1883 skip_quoted (str)
1884      char *str;
1885 {
1886   char quote_char = '\0';
1887   char *scan;
1888
1889   for (scan = str; *scan != '\0'; scan++)
1890     {
1891       if (quote_char != '\0')
1892         {
1893           /* Ignore everything until the matching close quote char */
1894           if (*scan == quote_char)
1895             {
1896               /* Found matching close quote. */
1897               scan++;
1898               break;
1899             }
1900         }
1901       else if (strchr (gdb_completer_quote_characters, *scan))
1902         {
1903           /* Found start of a quoted string. */
1904           quote_char = *scan;
1905         }
1906       else if (strchr (gdb_completer_word_break_characters, *scan))
1907         {
1908           break;
1909         }
1910     }
1911   return (scan);
1912 }
1913
1914 \f
1915 #ifdef STOP_SIGNAL
1916 static void
1917 stop_sig (signo)
1918 int signo;
1919 {
1920 #if STOP_SIGNAL == SIGTSTP
1921   signal (SIGTSTP, SIG_DFL);
1922   sigsetmask (0);
1923   kill (getpid (), SIGTSTP);
1924   signal (SIGTSTP, stop_sig);
1925 #else
1926   signal (STOP_SIGNAL, stop_sig);
1927 #endif
1928   printf_unfiltered ("%s", prompt);
1929   gdb_flush (gdb_stdout);
1930
1931   /* Forget about any previous command -- null line now will do nothing.  */
1932   dont_repeat ();
1933 }
1934 #endif /* STOP_SIGNAL */
1935
1936 /* Initialize signal handlers. */
1937 static void
1938 do_nothing (signo)
1939 int signo;
1940 {
1941   /* Under System V the default disposition of a signal is reinstated after
1942      the signal is caught and delivered to an application process.  On such
1943      systems one must restore the replacement signal handler if one wishes
1944      to continue handling the signal in one's program.  On BSD systems this
1945      is not needed but it is harmless, and it simplifies the code to just do
1946      it unconditionally. */
1947   signal (signo, do_nothing);
1948 }
1949
1950 static void
1951 init_signals ()
1952 {
1953   signal (SIGINT, request_quit);
1954
1955   /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
1956      to the inferior and breakpoints will be ignored.  */
1957 #ifdef SIGTRAP
1958   signal (SIGTRAP, SIG_DFL);
1959 #endif
1960
1961   /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
1962      passed to the inferior, which we don't want.  It would be
1963      possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
1964      on BSD4.3 systems using vfork, that can affect the
1965      GDB process as well as the inferior (the signal handling tables
1966      might be in memory, shared between the two).  Since we establish
1967      a handler for SIGQUIT, when we call exec it will set the signal
1968      to SIG_DFL for us.  */
1969   signal (SIGQUIT, do_nothing);
1970 #ifdef SIGHUP
1971   if (signal (SIGHUP, do_nothing) != SIG_IGN)
1972     signal (SIGHUP, disconnect);
1973 #endif
1974   signal (SIGFPE, float_handler);
1975
1976 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1977   signal (SIGWINCH, SIGWINCH_HANDLER);
1978 #endif
1979 }
1980 \f
1981 /* Read one line from the command input stream `instream'
1982    into the local static buffer `linebuffer' (whose current length
1983    is `linelength').
1984    The buffer is made bigger as necessary.
1985    Returns the address of the start of the line.
1986
1987    NULL is returned for end of file.
1988
1989    *If* the instream == stdin & stdin is a terminal, the line read
1990    is copied into the file line saver (global var char *line,
1991    length linesize) so that it can be duplicated.
1992
1993    This routine either uses fancy command line editing or
1994    simple input as the user has requested.  */
1995
1996 char *
1997 command_line_input (prrompt, repeat, annotation_suffix)
1998      char *prrompt;
1999      int repeat;
2000      char *annotation_suffix;
2001 {
2002   static char *linebuffer = 0;
2003   static unsigned linelength = 0;
2004   register char *p;
2005   char *p1;
2006   char *rl;
2007   char *local_prompt = prrompt;
2008   char *nline;
2009   char got_eof = 0;
2010
2011   /* The annotation suffix must be non-NULL.  */
2012   if (annotation_suffix == NULL)
2013     annotation_suffix = "";
2014
2015   if (annotation_level > 1 && instream == stdin)
2016     {
2017       local_prompt = alloca ((prrompt == NULL ? 0 : strlen (prrompt))
2018                              + strlen (annotation_suffix) + 40);
2019       if (prrompt == NULL)
2020         local_prompt[0] = '\0';
2021       else
2022         strcpy (local_prompt, prrompt);
2023       strcat (local_prompt, "\n\032\032");
2024       strcat (local_prompt, annotation_suffix);
2025       strcat (local_prompt, "\n");
2026     }
2027
2028   if (linebuffer == 0)
2029     {
2030       linelength = 80;
2031       linebuffer = (char *) xmalloc (linelength);
2032     }
2033
2034   p = linebuffer;
2035
2036   /* Control-C quits instantly if typed while in this loop
2037      since it should not wait until the user types a newline.  */
2038   immediate_quit++;
2039 #ifdef STOP_SIGNAL
2040   if (job_control)
2041     signal (STOP_SIGNAL, stop_sig);
2042 #endif
2043
2044   while (1)
2045     {
2046       /* Make sure that all output has been output.  Some machines may let
2047          you get away with leaving out some of the gdb_flush, but not all.  */
2048       wrap_here ("");
2049       gdb_flush (gdb_stdout);
2050       gdb_flush (gdb_stderr);
2051
2052       if (source_file_name != NULL)
2053         {
2054           ++source_line_number;
2055           sprintf (source_error,
2056                    "%s%s:%d: Error in sourced command file:\n",
2057                    source_pre_error,
2058                    source_file_name,
2059                    source_line_number);
2060           error_pre_print = source_error;
2061         }
2062
2063       if (annotation_level > 1 && instream == stdin)
2064         {
2065           printf_unfiltered ("\n\032\032pre-");
2066           printf_unfiltered (annotation_suffix);
2067           printf_unfiltered ("\n");
2068         }
2069
2070       /* Don't use fancy stuff if not talking to stdin.  */
2071       if (readline_hook && instream == NULL)
2072         {
2073           rl = (*readline_hook) (local_prompt);
2074         }
2075       else if (command_editing_p && instream == stdin && ISATTY (instream))
2076         {
2077           rl = readline (local_prompt);
2078         }
2079       else
2080         {
2081           rl = gdb_readline (local_prompt);
2082         }
2083
2084       if (annotation_level > 1 && instream == stdin)
2085         {
2086           printf_unfiltered ("\n\032\032post-");
2087           printf_unfiltered (annotation_suffix);
2088           printf_unfiltered ("\n");
2089         }
2090
2091       if (!rl || rl == (char *) EOF)
2092         {
2093           got_eof = 1;
2094           break;
2095         }
2096       if (strlen(rl) + 1 + (p - linebuffer) > linelength)
2097         {
2098           linelength = strlen(rl) + 1 + (p - linebuffer);
2099           nline = (char *) xrealloc (linebuffer, linelength);
2100           p += nline - linebuffer;
2101           linebuffer = nline;
2102         }
2103       p1 = rl;
2104       /* Copy line.  Don't copy null at end.  (Leaves line alone
2105          if this was just a newline)  */
2106       while (*p1)
2107         *p++ = *p1++;
2108
2109       free (rl);                        /* Allocated in readline.  */
2110
2111       if (p == linebuffer || *(p - 1) != '\\')
2112         break;
2113
2114       p--;                      /* Put on top of '\'.  */
2115       local_prompt = (char *) 0;
2116   }
2117
2118 #ifdef STOP_SIGNAL
2119   if (job_control)
2120     signal (STOP_SIGNAL, SIG_DFL);
2121 #endif
2122   immediate_quit--;
2123
2124   if (got_eof)
2125     return NULL;
2126
2127 #define SERVER_COMMAND_LENGTH 7
2128   server_command =
2129     (p - linebuffer > SERVER_COMMAND_LENGTH)
2130       && STREQN (linebuffer, "server ", SERVER_COMMAND_LENGTH);
2131   if (server_command)
2132     {
2133       /* Note that we don't set `line'.  Between this and the check in
2134          dont_repeat, this insures that repeating will still do the
2135          right thing.  */
2136       *p = '\0';
2137       return linebuffer + SERVER_COMMAND_LENGTH;
2138     }
2139
2140   /* Do history expansion if that is wished.  */
2141   if (history_expansion_p && instream == stdin
2142       && ISATTY (instream))
2143     {
2144       char *history_value;
2145       int expanded;
2146
2147       *p = '\0';                /* Insert null now.  */
2148       expanded = history_expand (linebuffer, &history_value);
2149       if (expanded)
2150         {
2151           /* Print the changes.  */
2152           printf_unfiltered ("%s\n", history_value);
2153
2154           /* If there was an error, call this function again.  */
2155           if (expanded < 0)
2156             {
2157               free (history_value);
2158               return command_line_input (prrompt, repeat, annotation_suffix);
2159             }
2160           if (strlen (history_value) > linelength)
2161             {
2162               linelength = strlen (history_value) + 1;
2163               linebuffer = (char *) xrealloc (linebuffer, linelength);
2164             }
2165           strcpy (linebuffer, history_value);
2166           p = linebuffer + strlen(linebuffer);
2167           free (history_value);
2168         }
2169     }
2170
2171   /* If we just got an empty line, and that is supposed
2172      to repeat the previous command, return the value in the
2173      global buffer.  */
2174   if (repeat && p == linebuffer)
2175     return line;
2176   for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++) ;
2177   if (repeat && !*p1)
2178     return line;
2179
2180   *p = 0;
2181
2182   /* Add line to history if appropriate.  */
2183   if (instream == stdin
2184       && ISATTY (stdin) && *linebuffer)
2185     add_history (linebuffer);
2186
2187   /* Note: lines consisting solely of comments are added to the command
2188      history.  This is useful when you type a command, and then
2189      realize you don't want to execute it quite yet.  You can comment
2190      out the command and then later fetch it from the value history
2191      and remove the '#'.  The kill ring is probably better, but some
2192      people are in the habit of commenting things out.  */
2193   if (*p1 == '#')
2194     *p1 = '\0';  /* Found a comment. */
2195
2196   /* Save into global buffer if appropriate.  */
2197   if (repeat)
2198     {
2199       if (linelength > linesize)
2200         {
2201           line = xrealloc (line, linelength);
2202           linesize = linelength;
2203         }
2204       strcpy (line, linebuffer);
2205       return line;
2206     }
2207
2208   return linebuffer;
2209 }
2210 \f
2211
2212 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
2213    code bodies.  This is typically used when we encounter an "else"
2214    clause for an "if" command.  */
2215
2216 static void
2217 realloc_body_list (command, new_length)
2218      struct command_line *command;
2219      int new_length;
2220 {
2221   int n;
2222   struct command_line **body_list;
2223
2224   n = command->body_count;
2225
2226   /* Nothing to do?  */
2227   if (new_length <= n)
2228     return;
2229
2230   body_list = (struct command_line **)
2231     xmalloc (sizeof (struct command_line *) * new_length);
2232
2233   memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
2234
2235   free (command->body_list);
2236   command->body_list = body_list;
2237   command->body_count = new_length;
2238 }
2239
2240 /* Read one line from the input stream.  If the command is an "else" or
2241    "end", return such an indication to the caller.  */
2242
2243 static enum misc_command_type
2244 read_next_line (command)
2245      struct command_line **command;
2246 {
2247   char *p, *p1, *prompt_ptr, control_prompt[256];
2248   int i = 0;
2249
2250   if (control_level >= 254)
2251     error ("Control nesting too deep!\n");
2252
2253   /* Set a prompt based on the nesting of the control commands.  */
2254   if (instream == stdin || (instream == 0 && readline_hook != NULL))
2255     {
2256       for (i = 0; i < control_level; i++)
2257         control_prompt[i] = ' ';
2258       control_prompt[i] = '>';
2259       control_prompt[i+1] = '\0';
2260       prompt_ptr = (char *)&control_prompt[0];
2261     }
2262   else
2263     prompt_ptr = NULL;
2264
2265   p = command_line_input (prompt_ptr, instream == stdin, "commands");
2266
2267   /* Not sure what to do here.  */
2268   if (p == NULL)
2269     return end_command;
2270
2271   /* Strip leading and trailing whitespace.  */
2272   while (*p == ' ' || *p == '\t')
2273     p++;
2274
2275   p1 = p + strlen (p);
2276   while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t'))
2277     p1--;
2278
2279   /* Blanks and comments don't really do anything, but we need to
2280      distinguish them from else, end and other commands which can be
2281      executed.  */
2282   if (p1 == p || p[0] == '#')
2283     return nop_command;
2284
2285   /* Is this the end of a simple, while, or if control structure?  */
2286   if (p1 - p == 3 && !strncmp (p, "end", 3))
2287     return end_command;
2288
2289   /* Is the else clause of an if control structure?  */
2290   if (p1 - p == 4 && !strncmp (p, "else", 4))
2291     return else_command;
2292
2293   /* Check for while, if, break, continue, etc and build a new command
2294      line structure for them.  */
2295   if (p1 - p > 5 && !strncmp (p, "while", 5))
2296     *command = build_command_line (while_control, p + 6);
2297   else if (p1 - p > 2 && !strncmp (p, "if", 2))
2298     *command = build_command_line (if_control, p + 3);
2299   else if (p1 - p == 10 && !strncmp (p, "loop_break", 10))
2300     {
2301       *command = (struct command_line *)
2302         xmalloc (sizeof (struct command_line));
2303       (*command)->next = NULL;
2304       (*command)->line = NULL;
2305       (*command)->control_type = break_control;
2306       (*command)->body_count = 0;
2307       (*command)->body_list = NULL;
2308     }
2309   else if (p1 - p == 13 && !strncmp (p, "loop_continue", 13))
2310     {
2311       *command = (struct command_line *)
2312         xmalloc (sizeof (struct command_line));
2313       (*command)->next = NULL;
2314       (*command)->line = NULL;
2315       (*command)->control_type = continue_control;
2316       (*command)->body_count = 0;
2317       (*command)->body_list = NULL;
2318     }
2319   else
2320     {
2321       /* A normal command.  */
2322       *command = (struct command_line *)
2323         xmalloc (sizeof (struct command_line));
2324       (*command)->next = NULL;
2325       (*command)->line = savestring (p, p1 - p);
2326       (*command)->control_type = simple_control;
2327       (*command)->body_count = 0;
2328       (*command)->body_list = NULL;
2329   }
2330
2331   /* Nothing special.  */
2332   return ok_command;
2333 }
2334
2335 /* Recursively read in the control structures and create a command_line
2336    structure from them.
2337
2338    The parent_control parameter is the control structure in which the
2339    following commands are nested.  */
2340
2341 static enum command_control_type
2342 recurse_read_control_structure (current_cmd)
2343      struct command_line *current_cmd;
2344 {
2345   int current_body, i;
2346   enum misc_command_type val;
2347   enum command_control_type ret;
2348   struct command_line **body_ptr, *child_tail, *next;
2349
2350   child_tail = NULL;
2351   current_body = 1;
2352
2353   /* Sanity checks.  */
2354   if (current_cmd->control_type == simple_control)
2355     {
2356       error ("Recursed on a simple control type\n");
2357       return invalid_control;
2358     }
2359
2360   if (current_body > current_cmd->body_count)
2361     {
2362       error ("Allocated body is smaller than this command type needs\n");
2363       return invalid_control;
2364     }
2365
2366   /* Read lines from the input stream and build control structures.  */
2367   while (1)
2368     {
2369       dont_repeat ();
2370
2371       next = NULL;
2372       val = read_next_line (&next);
2373
2374       /* Just skip blanks and comments.  */
2375       if (val == nop_command)
2376         continue;
2377
2378       if (val == end_command)
2379         {
2380           if (current_cmd->control_type == while_control
2381               || current_cmd->control_type == if_control)
2382             {
2383               /* Success reading an entire control structure.  */
2384               ret = simple_control;
2385               break;
2386             }
2387           else
2388             {
2389               ret = invalid_control;
2390               break;
2391             }
2392         }
2393
2394       /* Not the end of a control structure.  */
2395       if (val == else_command)
2396         {
2397           if (current_cmd->control_type == if_control
2398               && current_body == 1)
2399             {
2400               realloc_body_list (current_cmd, 2);
2401               current_body = 2;
2402               child_tail = NULL;
2403               continue;
2404             }
2405           else
2406             {
2407               ret = invalid_control;
2408               break;
2409             }
2410         }
2411
2412       if (child_tail)
2413         {
2414           child_tail->next = next;
2415         }
2416       else
2417         {
2418           body_ptr = current_cmd->body_list;
2419           for (i = 1; i < current_body; i++)
2420             body_ptr++;
2421
2422           *body_ptr = next;
2423
2424         }
2425
2426       child_tail = next;
2427
2428       /* If the latest line is another control structure, then recurse
2429          on it.  */
2430       if (next->control_type == while_control
2431           || next->control_type == if_control)
2432         {
2433           control_level++;
2434           ret = recurse_read_control_structure (next);
2435           control_level--;
2436
2437           if (ret != simple_control)
2438             break;
2439         }
2440     }
2441
2442   dont_repeat ();
2443
2444   return ret;
2445 }
2446
2447 /* Read lines from the input stream and accumulate them in a chain of
2448    struct command_line's, which is then returned.  For input from a
2449    terminal, the special command "end" is used to mark the end of the
2450    input, and is not included in the returned chain of commands. */
2451
2452 #define END_MESSAGE "End with a line saying just \"end\"."
2453
2454 struct command_line *
2455 read_command_lines (prompt, from_tty)
2456 char *prompt;
2457 int from_tty;
2458 {
2459   struct command_line *head, *tail, *next;
2460   struct cleanup *old_chain;
2461   enum command_control_type ret;
2462   enum misc_command_type val;
2463
2464   if (readline_begin_hook)
2465     {
2466       /* Note - intentional to merge messages with no newline */
2467       (*readline_begin_hook) ("%s  %s\n", prompt, END_MESSAGE);
2468     }
2469   else if (from_tty && input_from_terminal_p ())
2470     {
2471       printf_unfiltered ("%s\n%s\n", prompt, END_MESSAGE);
2472       gdb_flush (gdb_stdout);
2473     }
2474
2475   head = tail = NULL;
2476   old_chain = NULL;
2477
2478   while (1)
2479     {
2480       val = read_next_line (&next);
2481
2482       /* Ignore blank lines or comments.  */
2483       if (val == nop_command)
2484         continue;
2485
2486       if (val == end_command)
2487         {
2488           ret = simple_control;
2489           break;
2490         }
2491
2492       if (val != ok_command)
2493         {
2494           ret = invalid_control;
2495           break;
2496         }
2497
2498       if (next->control_type == while_control
2499           || next->control_type == if_control)
2500         {
2501           control_level++;
2502           ret = recurse_read_control_structure (next);
2503           control_level--;
2504
2505           if (ret == invalid_control)
2506             break;
2507         }
2508
2509       if (tail)
2510         {
2511           tail->next = next;
2512         }
2513       else
2514         {
2515           head = next;
2516           old_chain = make_cleanup ((make_cleanup_func) free_command_lines,
2517                                     &head);
2518         }
2519       tail = next;
2520     }
2521
2522   dont_repeat ();
2523
2524   if (head)
2525     {
2526       if (ret != invalid_control)
2527         {
2528           discard_cleanups (old_chain);
2529         }
2530       else
2531         do_cleanups (old_chain);
2532     }
2533
2534   if (readline_end_hook)
2535     {
2536       (*readline_end_hook) ();
2537     }
2538   return (head);
2539 }
2540
2541 /* Free a chain of struct command_line's.  */
2542
2543 void
2544 free_command_lines (lptr)
2545       struct command_line **lptr;
2546 {
2547   register struct command_line *l = *lptr;
2548   register struct command_line *next;
2549   struct command_line **blist;
2550   int i;
2551
2552   while (l)
2553     {
2554       if (l->body_count > 0)
2555         {
2556           blist = l->body_list;
2557           for (i = 0; i < l->body_count; i++, blist++)
2558             free_command_lines (blist);
2559         }
2560       next = l->next;
2561       free (l->line);
2562       free ((PTR)l);
2563       l = next;
2564     }
2565 }
2566 \f
2567 /* Add an element to the list of info subcommands.  */
2568
2569 void
2570 add_info (name, fun, doc)
2571      char *name;
2572      void (*fun) PARAMS ((char *, int));
2573      char *doc;
2574 {
2575   add_cmd (name, no_class, fun, doc, &infolist);
2576 }
2577
2578 /* Add an alias to the list of info subcommands.  */
2579
2580 void
2581 add_info_alias (name, oldname, abbrev_flag)
2582      char *name;
2583      char *oldname;
2584      int abbrev_flag;
2585 {
2586   add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
2587 }
2588
2589 /* The "info" command is defined as a prefix, with allow_unknown = 0.
2590    Therefore, its own definition is called only for "info" with no args.  */
2591
2592 /* ARGSUSED */
2593 static void
2594 info_command (arg, from_tty)
2595      char *arg;
2596      int from_tty;
2597 {
2598   printf_unfiltered ("\"info\" must be followed by the name of an info command.\n");
2599   help_list (infolist, "info ", -1, gdb_stdout);
2600 }
2601
2602 /* The "complete" command is used by Emacs to implement completion.  */
2603
2604 /* ARGSUSED */
2605 static void
2606 complete_command (arg, from_tty)
2607      char *arg;
2608      int from_tty;
2609 {
2610   int i;
2611   int argpoint;
2612   char *completion;
2613
2614   dont_repeat ();
2615
2616   if (arg == NULL)
2617     arg = "";
2618   argpoint = strlen (arg);
2619
2620   for (completion = line_completion_function (arg, i = 0, arg, argpoint);
2621        completion;
2622        completion = line_completion_function (arg, ++i, arg, argpoint))
2623     {
2624       printf_unfiltered ("%s\n", completion);
2625       free (completion);
2626     }
2627 }
2628
2629 /* The "show" command with no arguments shows all the settings.  */
2630
2631 /* ARGSUSED */
2632 static void
2633 show_command (arg, from_tty)
2634      char *arg;
2635      int from_tty;
2636 {
2637   cmd_show_list (showlist, from_tty, "");
2638 }
2639 \f
2640 /* Add an element to the list of commands.  */
2641
2642 void
2643 add_com (name, class, fun, doc)
2644      char *name;
2645      enum command_class class;
2646      void (*fun) PARAMS ((char *, int));
2647      char *doc;
2648 {
2649   add_cmd (name, class, fun, doc, &cmdlist);
2650 }
2651
2652 /* Add an alias or abbreviation command to the list of commands.  */
2653
2654 void
2655 add_com_alias (name, oldname, class, abbrev_flag)
2656      char *name;
2657      char *oldname;
2658      enum command_class class;
2659      int abbrev_flag;
2660 {
2661   add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
2662 }
2663
2664 void
2665 error_no_arg (why)
2666      char *why;
2667 {
2668   error ("Argument required (%s).", why);
2669 }
2670
2671 /* ARGSUSED */
2672 static void
2673 help_command (command, from_tty)
2674      char *command;
2675      int from_tty; /* Ignored */
2676 {
2677   help_cmd (command, gdb_stdout);
2678 }
2679 \f
2680 static void
2681 validate_comname (comname)
2682      char *comname;
2683 {
2684   register char *p;
2685
2686   if (comname == 0)
2687     error_no_arg ("name of command to define");
2688
2689   p = comname;
2690   while (*p)
2691     {
2692       if (!isalnum(*p) && *p != '-' && *p != '_')
2693         error ("Junk in argument list: \"%s\"", p);
2694       p++;
2695     }
2696 }
2697
2698 /* This is just a placeholder in the command data structures.  */
2699 static void
2700 user_defined_command (ignore, from_tty)
2701      char *ignore;
2702      int from_tty;
2703 {
2704 }
2705
2706 static void
2707 define_command (comname, from_tty)
2708      char *comname;
2709      int from_tty;
2710 {
2711   register struct command_line *cmds;
2712   register struct cmd_list_element *c, *newc, *hookc = 0;
2713   char *tem = comname;
2714   char tmpbuf[128];
2715 #define HOOK_STRING     "hook-"
2716 #define HOOK_LEN 5
2717
2718   validate_comname (comname);
2719
2720   /* Look it up, and verify that we got an exact match.  */
2721   c = lookup_cmd (&tem, cmdlist, "", -1, 1);
2722   if (c && !STREQ (comname, c->name))
2723     c = 0;
2724
2725   if (c)
2726     {
2727       if (c->class == class_user || c->class == class_alias)
2728         tem = "Redefine command \"%s\"? ";
2729       else
2730         tem = "Really redefine built-in command \"%s\"? ";
2731       if (!query (tem, c->name))
2732         error ("Command \"%s\" not redefined.", c->name);
2733     }
2734
2735   /* If this new command is a hook, then mark the command which it
2736      is hooking.  Note that we allow hooking `help' commands, so that
2737      we can hook the `stop' pseudo-command.  */
2738
2739   if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
2740     {
2741       /* Look up cmd it hooks, and verify that we got an exact match.  */
2742       tem = comname+HOOK_LEN;
2743       hookc = lookup_cmd (&tem, cmdlist, "", -1, 0);
2744       if (hookc && !STREQ (comname+HOOK_LEN, hookc->name))
2745         hookc = 0;
2746       if (!hookc)
2747         {
2748           warning ("Your new `%s' command does not hook any existing command.",
2749                    comname);
2750           if (!query ("Proceed? "))
2751             error ("Not confirmed.");
2752         }
2753     }
2754
2755   comname = savestring (comname, strlen (comname));
2756
2757   /* If the rest of the commands will be case insensitive, this one
2758      should behave in the same manner. */
2759   for (tem = comname; *tem; tem++)
2760     if (isupper(*tem)) *tem = tolower(*tem);
2761
2762   control_level = 0;
2763   sprintf (tmpbuf, "Type commands for definition of \"%s\".", comname);
2764   cmds = read_command_lines (tmpbuf, from_tty);
2765
2766   if (c && c->class == class_user)
2767     free_command_lines (&c->user_commands);
2768
2769   newc = add_cmd (comname, class_user, user_defined_command,
2770            (c && c->class == class_user)
2771            ? c->doc : savestring ("User-defined.", 13), &cmdlist);
2772   newc->user_commands = cmds;
2773
2774   /* If this new command is a hook, then mark both commands as being
2775      tied.  */
2776   if (hookc)
2777     {
2778       hookc->hook = newc;       /* Target gets hooked.  */
2779       newc->hookee = hookc;     /* We are marked as hooking target cmd.  */
2780     }
2781 }
2782
2783 static void
2784 document_command (comname, from_tty)
2785      char *comname;
2786      int from_tty;
2787 {
2788   struct command_line *doclines;
2789   register struct cmd_list_element *c;
2790   char *tem = comname;
2791   char tmpbuf[128];
2792
2793   validate_comname (comname);
2794
2795   c = lookup_cmd (&tem, cmdlist, "", 0, 1);
2796
2797   if (c->class != class_user)
2798     error ("Command \"%s\" is built-in.", comname);
2799
2800   sprintf (tmpbuf, "Type documentation for \"%s\".", comname);
2801   doclines = read_command_lines (tmpbuf, from_tty);
2802
2803   if (c->doc) free (c->doc);
2804
2805   {
2806     register struct command_line *cl1;
2807     register int len = 0;
2808
2809     for (cl1 = doclines; cl1; cl1 = cl1->next)
2810       len += strlen (cl1->line) + 1;
2811
2812     c->doc = (char *) xmalloc (len + 1);
2813     *c->doc = 0;
2814
2815     for (cl1 = doclines; cl1; cl1 = cl1->next)
2816       {
2817         strcat (c->doc, cl1->line);
2818         if (cl1->next)
2819           strcat (c->doc, "\n");
2820       }
2821   }
2822
2823   free_command_lines (&doclines);
2824 }
2825 \f
2826 void
2827 print_gdb_version (stream)
2828   GDB_FILE *stream;
2829 {
2830   /* From GNU coding standards, first line is meant to be easy for a
2831      program to parse, and is just canonical program name and version
2832      number, which starts after last space. */
2833
2834   fprintf_filtered (stream, "GNU gdb %s\n", version);
2835
2836   /* Second line is a copyright notice. */
2837
2838   fprintf_filtered (stream, "Copyright 1998 Free Software Foundation, Inc.\n");
2839
2840   /* Following the copyright is a brief statement that the program is
2841      free software, that users are free to copy and change it on
2842      certain conditions, that it is covered by the GNU GPL, and that
2843      there is no warranty. */
2844
2845   fprintf_filtered (stream, "\
2846 GDB is free software, covered by the GNU General Public License, and you are\n\
2847 welcome to change it and/or distribute copies of it under certain conditions.\n\
2848 Type \"show copying\" to see the conditions.\n\
2849 There is absolutely no warranty for GDB.  Type \"show warranty\" for details.\n");
2850
2851   /* After the required info we print the configuration information. */
2852
2853   fprintf_filtered (stream, "This GDB was configured as \"");
2854   if (!STREQ (host_name, target_name))
2855     {
2856       fprintf_filtered (stream, "--host=%s --target=%s", host_name, target_name);
2857     }
2858   else
2859     {
2860       fprintf_filtered (stream, "%s", host_name);
2861     }
2862   fprintf_filtered (stream, "\".");
2863 }
2864
2865 /* ARGSUSED */
2866 static void
2867 show_version (args, from_tty)
2868      char *args;
2869      int from_tty;
2870 {
2871   immediate_quit++;
2872   print_gdb_version (gdb_stdout);
2873   printf_filtered ("\n");
2874   immediate_quit--;
2875 }
2876 \f
2877 /* xgdb calls this to reprint the usual GDB prompt.  Obsolete now that xgdb
2878    is obsolete.  */
2879
2880 void
2881 print_prompt ()
2882 {
2883   printf_unfiltered ("%s", prompt);
2884   gdb_flush (gdb_stdout);
2885 }
2886
2887 /* This replaces the above for the frontends: it returns a pointer
2888    to the prompt. */
2889 char *
2890 get_prompt ()
2891 {
2892   return prompt;
2893 }
2894 \f
2895 /* If necessary, make the user confirm that we should quit.  Return
2896    non-zero if we should quit, zero if we shouldn't.  */
2897
2898 int
2899 quit_confirm ()
2900 {
2901   if (inferior_pid != 0 && target_has_execution)
2902     {
2903       char *s;
2904
2905       /* This is something of a hack.  But there's no reliable way to
2906          see if a GUI is running.  The `use_windows' variable doesn't
2907          cut it.  */
2908       if (init_ui_hook)
2909         s = "A debugging session is active.\nDo you still want to close the debugger?";
2910       else if (attach_flag)
2911         s = "The program is running.  Quit anyway (and detach it)? ";
2912       else
2913         s = "The program is running.  Exit anyway? ";
2914
2915       if (! query (s))
2916         return 0;
2917     }
2918
2919   return 1;
2920 }
2921
2922 /* Quit without asking for confirmation.  */
2923
2924 void
2925 quit_force (args, from_tty)
2926      char *args;
2927      int from_tty;
2928 {
2929   int exit_code = 0;
2930
2931   /* An optional expression may be used to cause gdb to terminate with the
2932      value of that expression. */
2933   if (args)
2934     {
2935       value_ptr val = parse_and_eval (args);
2936
2937       exit_code = (int) value_as_long (val);
2938     }
2939
2940   if (inferior_pid != 0 && target_has_execution)
2941     {
2942       if (attach_flag)
2943         target_detach (args, from_tty);
2944       else
2945         target_kill ();
2946     }
2947
2948   /* UDI wants this, to kill the TIP.  */
2949   target_close (1);
2950
2951   /* Save the history information if it is appropriate to do so.  */
2952   if (write_history_p && history_filename)
2953     write_history (history_filename);
2954
2955   do_final_cleanups(ALL_CLEANUPS);      /* Do any final cleanups before exiting */
2956
2957   exit (exit_code);
2958 }
2959
2960 /* Handle the quit command.  */
2961
2962 void
2963 quit_command (args, from_tty)
2964      char *args;
2965      int from_tty;
2966 {
2967   if (! quit_confirm ())
2968     error ("Not confirmed.");
2969   quit_force (args, from_tty);
2970 }
2971
2972 /* Returns whether GDB is running on a terminal and whether the user
2973    desires that questions be asked of them on that terminal.  */
2974
2975 int
2976 input_from_terminal_p ()
2977 {
2978   return gdb_has_a_terminal () && (instream == stdin) & caution;
2979 }
2980 \f
2981 /* ARGSUSED */
2982 static void
2983 pwd_command (args, from_tty)
2984      char *args;
2985      int from_tty;
2986 {
2987   if (args) error ("The \"pwd\" command does not take an argument: %s", args);
2988   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
2989
2990   if (!STREQ (gdb_dirbuf, current_directory))
2991     printf_unfiltered ("Working directory %s\n (canonically %s).\n",
2992             current_directory, gdb_dirbuf);
2993   else
2994     printf_unfiltered ("Working directory %s.\n", current_directory);
2995 }
2996
2997 void
2998 cd_command (dir, from_tty)
2999      char *dir;
3000      int from_tty;
3001 {
3002   int len;
3003   /* Found something other than leading repetitions of "/..".  */
3004   int found_real_path;
3005   char *p;
3006
3007   /* If the new directory is absolute, repeat is a no-op; if relative,
3008      repeat might be useful but is more likely to be a mistake.  */
3009   dont_repeat ();
3010
3011   if (dir == 0)
3012     error_no_arg ("new working directory");
3013
3014   dir = tilde_expand (dir);
3015   make_cleanup (free, dir);
3016
3017   if (chdir (dir) < 0)
3018     perror_with_name (dir);
3019
3020   len = strlen (dir);
3021   dir = savestring (dir, len - (len > 1 && SLASH_P(dir[len-1])));
3022   if (ROOTED_P(dir))
3023     current_directory = dir;
3024   else
3025     {
3026       if (SLASH_P (current_directory[0]) && current_directory[1] == '\0')
3027         current_directory = concat (current_directory, dir, NULL);
3028       else
3029         current_directory = concat (current_directory, SLASH_STRING, dir, NULL);
3030       free (dir);
3031     }
3032
3033   /* Now simplify any occurrences of `.' and `..' in the pathname.  */
3034
3035   found_real_path = 0;
3036   for (p = current_directory; *p;)
3037     {
3038       if (SLASH_P (p[0]) && p[1] == '.' && (p[2] == 0 || SLASH_P (p[2])))
3039         strcpy (p, p + 2);
3040       else if (SLASH_P (p[0]) && p[1] == '.' && p[2] == '.'
3041                && (p[3] == 0 || SLASH_P (p[3])))
3042         {
3043           if (found_real_path)
3044             {
3045               /* Search backwards for the directory just before the "/.."
3046                  and obliterate it and the "/..".  */
3047               char *q = p;
3048               while (q != current_directory && ! SLASH_P (q[-1]))
3049                 --q;
3050
3051               if (q == current_directory)
3052                 /* current_directory is
3053                    a relative pathname ("can't happen"--leave it alone).  */
3054                 ++p;
3055               else
3056                 {
3057                   strcpy (q - 1, p + 3);
3058                   p = q - 1;
3059                 }
3060             }
3061           else
3062             /* We are dealing with leading repetitions of "/..", for example
3063                "/../..", which is the Mach super-root.  */
3064             p += 3;
3065         }
3066       else
3067         {
3068           found_real_path = 1;
3069           ++p;
3070         }
3071     }
3072
3073   forget_cached_source_info ();
3074
3075   if (from_tty)
3076     pwd_command ((char *) 0, 1);
3077 }
3078 \f
3079 struct source_cleanup_lines_args {
3080   int old_line;
3081   char *old_file;
3082   char *old_pre_error;
3083   char *old_error_pre_print;
3084 };
3085
3086 static void
3087 source_cleanup_lines (args)
3088      PTR args;
3089 {
3090   struct source_cleanup_lines_args *p =
3091     (struct source_cleanup_lines_args *)args;
3092   source_line_number = p->old_line;
3093   source_file_name = p->old_file;
3094   source_pre_error = p->old_pre_error;
3095   error_pre_print = p->old_error_pre_print;
3096 }
3097
3098 /* ARGSUSED */
3099 void
3100 source_command (args, from_tty)
3101      char *args;
3102      int from_tty;
3103 {
3104   FILE *stream;
3105   struct cleanup *old_cleanups;
3106   char *file = args;
3107   struct source_cleanup_lines_args old_lines;
3108   int needed_length;
3109
3110   if (file == NULL)
3111     {
3112       error ("source command requires pathname of file to source.");
3113     }
3114
3115   file = tilde_expand (file);
3116   old_cleanups = make_cleanup (free, file);
3117
3118   stream = fopen (file, FOPEN_RT);
3119   if (!stream)
3120     if (from_tty)
3121       perror_with_name (file);
3122     else
3123       return;
3124
3125   make_cleanup ((make_cleanup_func) fclose, stream);
3126
3127   old_lines.old_line = source_line_number;
3128   old_lines.old_file = source_file_name;
3129   old_lines.old_pre_error = source_pre_error;
3130   old_lines.old_error_pre_print = error_pre_print;
3131   make_cleanup (source_cleanup_lines, &old_lines);
3132   source_line_number = 0;
3133   source_file_name = file;
3134   source_pre_error = error_pre_print == NULL ? "" : error_pre_print;
3135   source_pre_error = savestring (source_pre_error, strlen (source_pre_error));
3136   make_cleanup (free, source_pre_error);
3137   /* This will get set every time we read a line.  So it won't stay "" for
3138      long.  */
3139   error_pre_print = "";
3140
3141   needed_length = strlen (source_file_name) + strlen (source_pre_error) + 80;
3142   if (source_error_allocated < needed_length)
3143     {
3144       source_error_allocated *= 2;
3145       if (source_error_allocated < needed_length)
3146         source_error_allocated = needed_length;
3147       if (source_error == NULL)
3148         source_error = xmalloc (source_error_allocated);
3149       else
3150         source_error = xrealloc (source_error, source_error_allocated);
3151     }
3152
3153   read_command_file (stream);
3154
3155   do_cleanups (old_cleanups);
3156 }
3157
3158 /* ARGSUSED */
3159 static void
3160 echo_command (text, from_tty)
3161      char *text;
3162      int from_tty;
3163 {
3164   char *p = text;
3165   register int c;
3166
3167   if (text)
3168     while ((c = *p++) != '\0')
3169       {
3170         if (c == '\\')
3171           {
3172             /* \ at end of argument is used after spaces
3173                so they won't be lost.  */
3174             if (*p == 0)
3175               return;
3176
3177             c = parse_escape (&p);
3178             if (c >= 0)
3179               printf_filtered ("%c", c);
3180           }
3181         else
3182           printf_filtered ("%c", c);
3183       }
3184
3185   /* Force this output to appear now.  */
3186   wrap_here ("");
3187   gdb_flush (gdb_stdout);
3188 }
3189
3190 /* ARGSUSED */
3191 static void
3192 dont_repeat_command (ignored, from_tty)
3193      char *ignored;
3194      int from_tty;
3195 {
3196   *line = 0;            /* Can't call dont_repeat here because we're not
3197                            necessarily reading from stdin.  */
3198 }
3199 \f
3200 /* Functions to manipulate the endianness of the target.  */
3201
3202 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3203 #ifndef TARGET_BYTE_ORDER_DEFAULT
3204 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
3205 #endif
3206 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
3207 int target_byte_order_auto = 1;
3208 #else
3209 static int target_byte_order_auto = 0;
3210 #endif
3211
3212 /* Called if the user enters ``set endian'' without an argument.  */
3213 static void
3214 set_endian (args, from_tty)
3215      char *args;
3216      int from_tty;
3217 {
3218   printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
3219   show_endian (args, from_tty);
3220 }
3221
3222 /* Called by ``set endian big''.  */
3223 static void
3224 set_endian_big (args, from_tty)
3225      char *args;
3226      int from_tty;
3227 {
3228 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3229   target_byte_order = BIG_ENDIAN;
3230   target_byte_order_auto = 0;
3231 #else
3232   printf_unfiltered ("Byte order is not selectable.");
3233   show_endian (args, from_tty);
3234 #endif
3235 }
3236
3237 /* Called by ``set endian little''.  */
3238 static void
3239 set_endian_little (args, from_tty)
3240      char *args;
3241      int from_tty;
3242 {
3243 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3244   target_byte_order = LITTLE_ENDIAN;
3245   target_byte_order_auto = 0;
3246 #else
3247   printf_unfiltered ("Byte order is not selectable.");
3248   show_endian (args, from_tty);
3249 #endif
3250 }
3251
3252 /* Called by ``set endian auto''.  */
3253 static void
3254 set_endian_auto (args, from_tty)
3255      char *args;
3256      int from_tty;
3257 {
3258 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3259   target_byte_order_auto = 1;
3260 #else
3261   printf_unfiltered ("Byte order is not selectable.");
3262   show_endian (args, from_tty);
3263 #endif
3264 }
3265
3266 /* Called by ``show endian''.  */
3267 static void
3268 show_endian (args, from_tty)
3269      char *args;
3270      int from_tty;
3271 {
3272   const char *msg =
3273     (target_byte_order_auto
3274      ? "The target endianness is set automatically (currently %s endian)\n"
3275      : "The target is assumed to be %s endian\n");
3276   printf_unfiltered ((char *) msg, TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
3277 }
3278
3279 /* Set the endianness from a BFD.  */
3280 void
3281 set_endian_from_file (abfd)
3282      bfd *abfd;
3283 {
3284 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3285   int want;
3286
3287   if (bfd_big_endian (abfd))
3288     want = BIG_ENDIAN;
3289   else
3290     want = LITTLE_ENDIAN;
3291   if (target_byte_order_auto)
3292     target_byte_order = want;
3293   else if (target_byte_order != want)
3294     warning ("%s endian file does not match %s endian target.",
3295              want == BIG_ENDIAN ? "big" : "little",
3296              TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
3297
3298 #else /* ! defined (TARGET_BYTE_ORDER_SELECTABLE) */
3299
3300   if (bfd_big_endian (abfd)
3301       ? TARGET_BYTE_ORDER != BIG_ENDIAN
3302       : TARGET_BYTE_ORDER == BIG_ENDIAN)
3303     warning ("%s endian file does not match %s endian target.",
3304              bfd_big_endian (abfd) ? "big" : "little",
3305              TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
3306
3307 #endif /* ! defined (TARGET_BYTE_ORDER_SELECTABLE) */
3308 }
3309 \f
3310 /* Functions to manipulate the architecture of the target */
3311
3312 int target_architecture_auto = 1;
3313 extern const bfd_arch_info_type bfd_default_arch_struct;
3314 const bfd_arch_info_type *target_architecture = &bfd_default_arch_struct;
3315 int (*target_architecture_hook) PARAMS ((const bfd_arch_info_type *ap));
3316
3317 static void
3318 set_arch (arch)
3319      const bfd_arch_info_type *arch;
3320 {
3321   /* FIXME: Is it compatible with gdb? */
3322   /* Check with the target on the setting */
3323   if (target_architecture_hook != NULL
3324       && !target_architecture_hook (arch))
3325     printf_unfiltered ("Target does not support `%s' architecture.\n",
3326                        arch->printable_name);
3327   else
3328     {
3329       target_architecture_auto = 0;
3330       target_architecture = arch;
3331     }
3332 }
3333
3334
3335 /* Called if the user enters ``set architecture'' with or without an
3336    argument. */
3337 static void
3338 set_architecture (args, from_tty)
3339      char *args;
3340      int from_tty;
3341 {
3342   if (args == NULL)
3343     {
3344       printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
3345     }
3346   else if (strcmp (args, "auto") == 0)
3347     {
3348       target_architecture_auto = 1;
3349     }
3350   else
3351     {
3352       const bfd_arch_info_type *arch = bfd_scan_arch (args);
3353       if (arch != NULL)
3354         set_arch (arch);
3355       else
3356         printf_unfiltered ("Architecture `%s' not reconized.\n", args);
3357     }
3358 }
3359
3360 /* Called if the user enters ``show architecture'' without an argument. */
3361 static void
3362 show_architecture (args, from_tty)
3363      char *args;
3364      int from_tty;
3365 {
3366   const char *arch;
3367   arch = target_architecture->printable_name;
3368   if (target_architecture_auto)
3369     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
3370   else
3371     printf_filtered ("The target architecture is assumed to be %s\n", arch);
3372 }
3373
3374 /* Called if the user enters ``info architecture'' without an argument. */
3375 static void
3376 info_architecture (args, from_tty)
3377      char *args;
3378      int from_tty;
3379 {
3380   enum bfd_architecture a;
3381   printf_filtered ("Available architectures are:\n");
3382   for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
3383     {
3384       const bfd_arch_info_type *ap = bfd_lookup_arch (a, 0);
3385       if (ap != NULL)
3386         {
3387           do
3388             {
3389               printf_filtered (" %s", ap->printable_name);
3390               ap = ap->next;
3391             }
3392           while (ap != NULL);
3393           printf_filtered ("\n");
3394         }
3395     }
3396 }
3397
3398 /* Set the architecture from arch/machine */
3399 void
3400 set_architecture_from_arch_mach (arch, mach)
3401      enum bfd_architecture arch;
3402      unsigned long mach;
3403 {
3404   const bfd_arch_info_type *wanted = bfd_lookup_arch (arch, mach);
3405   if (wanted != NULL)
3406     set_arch (wanted);
3407   else
3408     fatal ("hardwired architecture/machine not reconized");
3409 }
3410
3411
3412 /* Set the architecture from a BFD */
3413 void
3414 set_architecture_from_file (abfd)
3415      bfd *abfd;
3416 {
3417   const bfd_arch_info_type *wanted = bfd_get_arch_info (abfd);
3418   if (target_architecture_auto)
3419     {
3420       if (target_architecture_hook != NULL
3421           && !target_architecture_hook (wanted))
3422         warning ("Target may not support %s architecture",
3423                  wanted->printable_name);
3424       target_architecture = wanted;
3425     }
3426   else if (wanted != target_architecture)
3427     {
3428       warning ("%s architecture file may be incompatible with %s target.",
3429                wanted->printable_name,
3430                target_architecture->printable_name);
3431     }
3432 }
3433 \f
3434 /* Functions to manipulate command line editing control variables.  */
3435
3436 /* Number of commands to print in each call to show_commands.  */
3437 #define Hist_print 10
3438 static void
3439 show_commands (args, from_tty)
3440      char *args;
3441      int from_tty;
3442 {
3443   /* Index for history commands.  Relative to history_base.  */
3444   int offset;
3445
3446   /* Number of the history entry which we are planning to display next.
3447      Relative to history_base.  */
3448   static int num = 0;
3449
3450   /* The first command in the history which doesn't exist (i.e. one more
3451      than the number of the last command).  Relative to history_base.  */
3452   int hist_len;
3453
3454   extern HIST_ENTRY *history_get PARAMS ((int));
3455
3456   /* Print out some of the commands from the command history.  */
3457   /* First determine the length of the history list.  */
3458   hist_len = history_size;
3459   for (offset = 0; offset < history_size; offset++)
3460     {
3461       if (!history_get (history_base + offset))
3462         {
3463           hist_len = offset;
3464           break;
3465         }
3466     }
3467
3468   if (args)
3469     {
3470       if (args[0] == '+' && args[1] == '\0')
3471         /* "info editing +" should print from the stored position.  */
3472         ;
3473       else
3474         /* "info editing <exp>" should print around command number <exp>.  */
3475         num = (parse_and_eval_address (args) - history_base) - Hist_print / 2;
3476     }
3477   /* "show commands" means print the last Hist_print commands.  */
3478   else
3479     {
3480       num = hist_len - Hist_print;
3481     }
3482
3483   if (num < 0)
3484     num = 0;
3485
3486   /* If there are at least Hist_print commands, we want to display the last
3487      Hist_print rather than, say, the last 6.  */
3488   if (hist_len - num < Hist_print)
3489     {
3490       num = hist_len - Hist_print;
3491       if (num < 0)
3492         num = 0;
3493     }
3494
3495   for (offset = num; offset < num + Hist_print && offset < hist_len; offset++)
3496     {
3497       printf_filtered ("%5d  %s\n", history_base + offset,
3498               (history_get (history_base + offset))->line);
3499     }
3500
3501   /* The next command we want to display is the next one that we haven't
3502      displayed yet.  */
3503   num += Hist_print;
3504
3505   /* If the user repeats this command with return, it should do what
3506      "show commands +" does.  This is unnecessary if arg is null,
3507      because "show commands +" is not useful after "show commands".  */
3508   if (from_tty && args)
3509     {
3510       args[0] = '+';
3511       args[1] = '\0';
3512     }
3513 }
3514
3515 /* Called by do_setshow_command.  */
3516 /* ARGSUSED */
3517 static void
3518 set_history_size_command (args, from_tty, c)
3519      char *args;
3520      int from_tty;
3521      struct cmd_list_element *c;
3522 {
3523   if (history_size == INT_MAX)
3524     unstifle_history ();
3525   else if (history_size >= 0)
3526     stifle_history (history_size);
3527   else
3528     {
3529       history_size = INT_MAX;
3530       error ("History size must be non-negative");
3531     }
3532 }
3533
3534 /* ARGSUSED */
3535 static void
3536 set_history (args, from_tty)
3537      char *args;
3538      int from_tty;
3539 {
3540   printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
3541   help_list (sethistlist, "set history ", -1, gdb_stdout);
3542 }
3543
3544 /* ARGSUSED */
3545 static void
3546 show_history (args, from_tty)
3547      char *args;
3548      int from_tty;
3549 {
3550   cmd_show_list (showhistlist, from_tty, "");
3551 }
3552
3553 int info_verbose = 0;           /* Default verbose msgs off */
3554
3555 /* Called by do_setshow_command.  An elaborate joke.  */
3556 /* ARGSUSED */
3557 static void
3558 set_verbose (args, from_tty, c)
3559      char *args;
3560      int from_tty;
3561      struct cmd_list_element *c;
3562 {
3563   char *cmdname = "verbose";
3564   struct cmd_list_element *showcmd;
3565
3566   showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
3567
3568   if (info_verbose)
3569     {
3570       c->doc = "Set verbose printing of informational messages.";
3571       showcmd->doc = "Show verbose printing of informational messages.";
3572     }
3573   else
3574     {
3575       c->doc = "Set verbosity.";
3576       showcmd->doc = "Show verbosity.";
3577     }
3578 }
3579
3580 static void
3581 float_handler (signo)
3582 int signo;
3583 {
3584   /* This message is based on ANSI C, section 4.7.  Note that integer
3585      divide by zero causes this, so "float" is a misnomer.  */
3586   signal (SIGFPE, float_handler);
3587   error ("Erroneous arithmetic operation.");
3588 }
3589
3590 \f
3591 static void
3592 init_cmd_lists ()
3593 {
3594   cmdlist = NULL;
3595   infolist = NULL;
3596   enablelist = NULL;
3597   disablelist = NULL;
3598   deletelist = NULL;
3599   enablebreaklist = NULL;
3600   setlist = NULL;
3601   unsetlist = NULL;
3602   showlist = NULL;
3603   endianlist = NULL;
3604   sethistlist = NULL;
3605   showhistlist = NULL;
3606   unsethistlist = NULL;
3607 #if MAINTENANCE_CMDS
3608   maintenancelist = NULL;
3609   maintenanceinfolist = NULL;
3610   maintenanceprintlist = NULL;
3611 #endif
3612   setprintlist = NULL;
3613   showprintlist = NULL;
3614   setchecklist = NULL;
3615   showchecklist = NULL;
3616 }
3617
3618 /* Init the history buffer.  Note that we are called after the init file(s)
3619  * have been read so that the user can change the history file via his
3620  * .gdbinit file (for instance).  The GDBHISTFILE environment variable
3621  * overrides all of this.
3622  */
3623
3624 void
3625 init_history()
3626 {
3627   char *tmpenv;
3628
3629   tmpenv = getenv ("HISTSIZE");
3630   if (tmpenv)
3631     history_size = atoi (tmpenv);
3632   else if (!history_size)
3633     history_size = 256;
3634
3635   stifle_history (history_size);
3636
3637   tmpenv = getenv ("GDBHISTFILE");
3638   if (tmpenv)
3639     history_filename = savestring (tmpenv, strlen(tmpenv));
3640   else if (!history_filename) {
3641     /* We include the current directory so that if the user changes
3642        directories the file written will be the same as the one
3643        that was read.  */
3644     history_filename = concat (current_directory, "/.gdb_history", NULL);
3645   }
3646   read_history (history_filename);
3647 }
3648
3649 static void
3650 init_main ()
3651 {
3652   struct cmd_list_element *c;
3653
3654   add_prefix_cmd ("endian", class_support, set_endian,
3655                   "Set endianness of target.",
3656                   &endianlist, "set endian ", 0, &setlist);
3657   add_cmd ("big", class_support, set_endian_big,
3658            "Set target as being big endian.", &endianlist);
3659   add_cmd ("little", class_support, set_endian_little,
3660            "Set target as being little endian.", &endianlist);
3661   add_cmd ("auto", class_support, set_endian_auto,
3662            "Select target endianness automatically.", &endianlist);
3663   add_cmd ("endian", class_support, show_endian,
3664            "Show endianness of target.", &showlist);
3665
3666   add_cmd ("architecture", class_support, set_architecture,
3667            "Set architecture of target.", &setlist);
3668   add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
3669   add_cmd ("architecture", class_support, show_architecture,
3670            "Show architecture of target.", &showlist);
3671   add_cmd ("architecture", class_support, info_architecture,
3672            "List supported target architectures", &infolist);
3673
3674
3675 #ifdef DEFAULT_PROMPT
3676   prompt = savestring (DEFAULT_PROMPT, strlen(DEFAULT_PROMPT));
3677 #else
3678   prompt = savestring ("(gdb) ", 6);
3679 #endif
3680
3681   /* Set the important stuff up for command editing.  */
3682   command_editing_p = 1;
3683   history_expansion_p = 0;
3684   write_history_p = 0;
3685
3686   /* Setup important stuff for command line editing.  */
3687   rl_completion_entry_function = (int (*)()) readline_line_completion_function;
3688   rl_completer_word_break_characters = gdb_completer_word_break_characters;
3689   rl_completer_quote_characters = gdb_completer_quote_characters;
3690   rl_readline_name = "gdb";
3691
3692   /* Define the classes of commands.
3693      They will appear in the help list in the reverse of this order.  */
3694
3695   add_cmd ("internals", class_maintenance, NO_FUNCTION,
3696            "Maintenance commands.\n\
3697 Some gdb commands are provided just for use by gdb maintainers.\n\
3698 These commands are subject to frequent change, and may not be as\n\
3699 well documented as user commands.",
3700            &cmdlist);
3701   add_cmd ("obscure", class_obscure, NO_FUNCTION, "Obscure features.", &cmdlist);
3702   add_cmd ("aliases", class_alias, NO_FUNCTION, "Aliases of other commands.", &cmdlist);
3703   add_cmd ("user-defined", class_user, NO_FUNCTION, "User-defined commands.\n\
3704 The commands in this class are those defined by the user.\n\
3705 Use the \"define\" command to define a command.", &cmdlist);
3706   add_cmd ("support", class_support, NO_FUNCTION, "Support facilities.", &cmdlist);
3707   add_cmd ("status", class_info, NO_FUNCTION, "Status inquiries.", &cmdlist);
3708   add_cmd ("files", class_files, NO_FUNCTION, "Specifying and examining files.", &cmdlist);
3709   add_cmd ("breakpoints", class_breakpoint, NO_FUNCTION, "Making program stop at certain points.", &cmdlist);
3710   add_cmd ("data", class_vars, NO_FUNCTION, "Examining data.", &cmdlist);
3711   add_cmd ("stack", class_stack, NO_FUNCTION, "Examining the stack.\n\
3712 The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
3713 counting from zero for the innermost (currently executing) frame.\n\n\
3714 At any time gdb identifies one frame as the \"selected\" frame.\n\
3715 Variable lookups are done with respect to the selected frame.\n\
3716 When the program being debugged stops, gdb selects the innermost frame.\n\
3717 The commands below can be used to select other frames by number or address.",
3718            &cmdlist);
3719   add_cmd ("running", class_run, NO_FUNCTION, "Running the program.", &cmdlist);
3720
3721   add_com ("pwd", class_files, pwd_command,
3722            "Print working directory.  This is used for your program as well.");
3723   c = add_cmd ("cd", class_files, cd_command,
3724            "Set working directory to DIR for debugger and program being debugged.\n\
3725 The change does not take effect for the program being debugged\n\
3726 until the next time it is started.", &cmdlist);
3727   c->completer = filename_completer;
3728
3729   add_show_from_set
3730     (add_set_cmd ("prompt", class_support, var_string, (char *)&prompt,
3731            "Set gdb's prompt",
3732            &setlist),
3733      &showlist);
3734
3735   add_com ("echo", class_support, echo_command,
3736            "Print a constant string.  Give string as argument.\n\
3737 C escape sequences may be used in the argument.\n\
3738 No newline is added at the end of the argument;\n\
3739 use \"\\n\" if you want a newline to be printed.\n\
3740 Since leading and trailing whitespace are ignored in command arguments,\n\
3741 if you want to print some you must use \"\\\" before leading whitespace\n\
3742 to be printed or after trailing whitespace.");
3743   add_com ("document", class_support, document_command,
3744            "Document a user-defined command.\n\
3745 Give command name as argument.  Give documentation on following lines.\n\
3746 End with a line of just \"end\".");
3747   add_com ("define", class_support, define_command,
3748            "Define a new command name.  Command name is argument.\n\
3749 Definition appears on following lines, one command per line.\n\
3750 End with a line of just \"end\".\n\
3751 Use the \"document\" command to give documentation for the new command.\n\
3752 Commands defined in this way may have up to ten arguments.");
3753
3754 #ifdef __STDC__
3755   c = add_cmd ("source", class_support, source_command,
3756            "Read commands from a file named FILE.\n\
3757 Note that the file \"" GDBINIT_FILENAME "\" is read automatically in this way\n\
3758 when gdb is started.", &cmdlist);
3759 #else
3760   /* Punt file name, we can't help it easily.  */
3761   c = add_cmd ("source", class_support, source_command,
3762            "Read commands from a file named FILE.\n\
3763 Note that the file \".gdbinit\" is read automatically in this way\n\
3764 when gdb is started.", &cmdlist);
3765 #endif
3766   c->completer = filename_completer;
3767
3768   add_com ("quit", class_support, quit_command, "Exit gdb.");
3769   add_com ("help", class_support, help_command, "Print list of commands.");
3770   add_com_alias ("q", "quit", class_support, 1);
3771   add_com_alias ("h", "help", class_support, 1);
3772
3773   add_com ("dont-repeat", class_support, dont_repeat_command, "Don't repeat this command.\n\
3774 Primarily used inside of user-defined commands that should not be repeated when\n\
3775 hitting return.");
3776
3777   c = add_set_cmd ("verbose", class_support, var_boolean, (char *)&info_verbose,
3778                    "Set ",
3779                    &setlist),
3780   add_show_from_set (c, &showlist);
3781   c->function.sfunc = set_verbose;
3782   set_verbose (NULL, 0, c);
3783
3784   add_show_from_set
3785     (add_set_cmd ("editing", class_support, var_boolean, (char *)&command_editing_p,
3786            "Set editing of command lines as they are typed.\n\
3787 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
3788 Without an argument, command line editing is enabled.  To edit, use\n\
3789 EMACS-like or VI-like commands like control-P or ESC.", &setlist),
3790      &showlist);
3791
3792   add_prefix_cmd ("history", class_support, set_history,
3793                   "Generic command for setting command history parameters.",
3794                   &sethistlist, "set history ", 0, &setlist);
3795   add_prefix_cmd ("history", class_support, show_history,
3796                   "Generic command for showing command history parameters.",
3797                   &showhistlist, "show history ", 0, &showlist);
3798
3799   add_show_from_set
3800     (add_set_cmd ("expansion", no_class, var_boolean, (char *)&history_expansion_p,
3801            "Set history expansion on command input.\n\
3802 Without an argument, history expansion is enabled.", &sethistlist),
3803      &showhistlist);
3804
3805   add_show_from_set
3806     (add_set_cmd ("save", no_class, var_boolean, (char *)&write_history_p,
3807            "Set saving of the history record on exit.\n\
3808 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
3809 Without an argument, saving is enabled.", &sethistlist),
3810      &showhistlist);
3811
3812   c = add_set_cmd ("size", no_class, var_integer, (char *)&history_size,
3813                    "Set the size of the command history, \n\
3814 ie. the number of previous commands to keep a record of.", &sethistlist);
3815   add_show_from_set (c, &showhistlist);
3816   c->function.sfunc = set_history_size_command;
3817
3818   add_show_from_set
3819     (add_set_cmd ("filename", no_class, var_filename, (char *)&history_filename,
3820            "Set the filename in which to record the command history\n\
3821  (the list of previous commands of which a record is kept).", &sethistlist),
3822      &showhistlist);
3823
3824   add_show_from_set
3825     (add_set_cmd ("confirm", class_support, var_boolean,
3826                   (char *)&caution,
3827                   "Set whether to confirm potentially dangerous operations.",
3828                   &setlist),
3829      &showlist);
3830
3831   add_prefix_cmd ("info", class_info, info_command,
3832         "Generic command for showing things about the program being debugged.",
3833                   &infolist, "info ", 0, &cmdlist);
3834   add_com_alias ("i", "info", class_info, 1);
3835
3836   add_com ("complete", class_obscure, complete_command,
3837            "List the completions for the rest of the line as a command.");
3838
3839   add_prefix_cmd ("show", class_info, show_command,
3840                   "Generic command for showing things about the debugger.",
3841                   &showlist, "show ", 0, &cmdlist);
3842   /* Another way to get at the same thing.  */
3843   add_info ("set", show_command, "Show all GDB settings.");
3844
3845   add_cmd ("commands", no_class, show_commands,
3846            "Show the history of commands you typed.\n\
3847 You can supply a command number to start with, or a `+' to start after\n\
3848 the previous command number shown.",
3849            &showlist);
3850
3851   add_cmd ("version", no_class, show_version,
3852            "Show what version of GDB this is.", &showlist);
3853
3854   add_com ("while", class_support, while_command,
3855 "Execute nested commands WHILE the conditional expression is non zero.\n\
3856 The conditional expression must follow the word `while' and must in turn be\n\
3857 followed by a new line.  The nested commands must be entered one per line,\n\
3858 and should be terminated by the word `end'.");
3859
3860   add_com ("if", class_support, if_command,
3861 "Execute nested commands once IF the conditional expression is non zero.\n\
3862 The conditional expression must follow the word `if' and must in turn be\n\
3863 followed by a new line.  The nested commands must be entered one per line,\n\
3864 and should be terminated by the word 'else' or `end'.  If an else clause\n\
3865 is used, the same rules apply to its nested commands as to the first ones.");
3866
3867   /* If target is open when baud changes, it doesn't take effect until the
3868      next open (I think, not sure).  */
3869   add_show_from_set (add_set_cmd ("remotebaud", no_class,
3870                                   var_zinteger, (char *)&baud_rate,
3871                                   "Set baud rate for remote serial I/O.\n\
3872 This value is used to set the speed of the serial port when debugging\n\
3873 using remote targets.", &setlist),
3874                      &showlist);
3875
3876   add_show_from_set (
3877     add_set_cmd ("remotedebug", no_class, var_zinteger, (char *)&remote_debug,
3878                    "Set debugging of remote protocol.\n\
3879 When enabled, each packet sent or received with the remote target\n\
3880 is displayed.", &setlist),
3881                      &showlist);
3882
3883   add_show_from_set (
3884     add_set_cmd ("remotetimeout", no_class, var_integer, (char *)&remote_timeout,
3885                    "Set timeout limit to wait for target to respond.\n\
3886 This value is used to set the time limit for gdb to wait for a response\n\
3887 from he target.", &setlist),
3888                      &showlist);
3889
3890   c = add_set_cmd ("annotate", class_obscure, var_zinteger,
3891                    (char *)&annotation_level, "Set annotation_level.\n\
3892 0 == normal;     1 == fullname (for use when running under emacs)\n\
3893 2 == output annotated suitably for use by programs that control GDB.",
3894                  &setlist);
3895   c = add_show_from_set (c, &showlist);
3896 }