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