gdb/top.c

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