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 #ifndef NO_SYS_FILE
  52 #include <sys/file.h>
  53 #endif
  54 #include <sys/param.h>
  55 #include "gdb_stat.h"
  56 #include <ctype.h>
  57
  58 extern void initialize_utils PARAMS ((void));
  59
  60 /* Prototypes for local functions */
  61
  62 static void dont_repeat_command PARAMS ((char *, int));
  63
  64 static void source_cleanup_lines PARAMS ((PTR));
  65
  66 static void user_defined_command PARAMS ((char *, int));
  67
  68 static void init_signals PARAMS ((void));
  69
  70 #ifdef STOP_SIGNAL
  71 static void stop_sig PARAMS ((int));
  72 #endif
  73
  74 static void disconnect PARAMS ((int));
  75
  76 static char * line_completion_function PARAMS ((char *, int, char *, int));
  77
  78 static char * readline_line_completion_function PARAMS ((char *, int));
  79
  80 static void command_loop_marker PARAMS ((int));
  81
  82 static void while_command PARAMS ((char *, int));
  83
  84 static void if_command PARAMS ((char *, int));
  85
  86 static struct command_line *
  87 build_command_line PARAMS ((enum command_control_type, char *));
  88
  89 static struct command_line *
  90 get_command_line PARAMS ((enum command_control_type, char *));
  91
  92 static void realloc_body_list PARAMS ((struct command_line *, int));
  93
  94 static enum misc_command_type read_next_line PARAMS ((struct command_line **));
  95
  96 static enum command_control_type
  97 recurse_read_control_structure PARAMS ((struct command_line *));
  98
  99 static struct cleanup * setup_user_args PARAMS ((char *));
 100
 101 static char * locate_arg PARAMS ((char *));
 102
 103 static char * insert_args PARAMS ((char *));
 104
 105 static void arg_cleanup PARAMS ((void));
 106
 107 static void init_main PARAMS ((void));
 108
 109 static void init_cmd_lists PARAMS ((void));
 110
 111 static void float_handler PARAMS ((int));
 112
 113 static void init_signals PARAMS ((void));
 114
 115 static void set_verbose PARAMS ((char *, int, struct cmd_list_element *));
 116
 117 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 118
 119 static void set_endian PARAMS ((char *, int));
 120
 121 static void set_endian_big PARAMS ((char *, int));
 122
 123 static void set_endian_little PARAMS ((char *, int));
 124
 125 static void set_endian_auto PARAMS ((char *, int));
 126
 127 static void show_endian PARAMS ((char *, int));
 128
 129 #endif
 130
 131 static void show_history PARAMS ((char *, int));
 132
 133 static void set_history PARAMS ((char *, int));
 134
 135 static void set_history_size_command PARAMS ((char *, int,
 136                                               struct cmd_list_element *));
 137
 138 static void show_commands PARAMS ((char *, int));
 139
 140 static void echo_command PARAMS ((char *, int));
 141
 142 static void pwd_command PARAMS ((char *, int));
 143
 144 static void show_version PARAMS ((char *, int));
 145
 146 static void document_command PARAMS ((char *, int));
 147
 148 static void define_command PARAMS ((char *, int));
 149
 150 static void validate_comname PARAMS ((char *));
 151
 152 static void help_command PARAMS ((char *, int));
 153
 154 static void show_command PARAMS ((char *, int));
 155
 156 static void info_command PARAMS ((char *, int));
 157
 158 static void complete_command PARAMS ((char *, int));
 159
 160 static void do_nothing PARAMS ((int));
 161
 162 static int quit_cover PARAMS ((char *));
 163
 164 static void disconnect PARAMS ((int));
 165
 166 static void source_cleanup PARAMS ((FILE *));
 167
 168 /* If this definition isn't overridden by the header files, assume
 169    that isatty and fileno exist on this system.  */
 170 #ifndef ISATTY
 171 #define ISATTY(FP)      (isatty (fileno (FP)))
 172 #endif
 173
 174 /* Initialization file name for gdb.  This is overridden in some configs.  */
 175
 176 #ifndef GDBINIT_FILENAME
 177 #define GDBINIT_FILENAME        ".gdbinit"
 178 #endif
 179 char gdbinit[] = GDBINIT_FILENAME;
 180
 181 int inhibit_gdbinit = 0;
 182
 183 /* If nonzero, and GDB has been configured to be able to use windows,
 184    attempt to open them upon startup.  */
 185
 186 int use_windows = 1;
 187
 188 /* Version number of GDB, as a string.  */
 189
 190 extern char *version;
 191
 192 /* Canonical host name as a string. */
 193
 194 extern char *host_name;
 195
 196 /* Canonical target name as a string. */
 197
 198 extern char *target_name;
 199
 200 extern char lang_frame_mismatch_warn[];         /* language.c */
 201
 202 /* Flag for whether we want all the "from_tty" gubbish printed.  */
 203
 204 int caution = 1;                        /* Default is yes, sigh. */
 205
 206 /* Define all cmd_list_elements.  */
 207
 208 /* Chain containing all defined commands.  */
 209
 210 struct cmd_list_element *cmdlist;
 211
 212 /* Chain containing all defined info subcommands.  */
 213
 214 struct cmd_list_element *infolist;
 215
 216 /* Chain containing all defined enable subcommands. */
 217
 218 struct cmd_list_element *enablelist;
 219
 220 /* Chain containing all defined disable subcommands. */
 221
 222 struct cmd_list_element *disablelist;
 223
 224 /* Chain containing all defined delete subcommands. */
 225
 226 struct cmd_list_element *deletelist;
 227
 228 /* Chain containing all defined "enable breakpoint" subcommands. */
 229
 230 struct cmd_list_element *enablebreaklist;
 231
 232 /* Chain containing all defined set subcommands */
 233
 234 struct cmd_list_element *setlist;
 235
 236 /* Chain containing all defined unset subcommands */
 237
 238 struct cmd_list_element *unsetlist;
 239
 240 /* Chain containing all defined show subcommands.  */
 241
 242 struct cmd_list_element *showlist;
 243
 244 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 245 /* Chain containing the \"set endian\" commands.  */
 246
 247 struct cmd_list_element *endianlist;
 248 #endif
 249
 250 /* Chain containing all defined \"set history\".  */
 251
 252 struct cmd_list_element *sethistlist;
 253
 254 /* Chain containing all defined \"show history\".  */
 255
 256 struct cmd_list_element *showhistlist;
 257
 258 /* Chain containing all defined \"unset history\".  */
 259
 260 struct cmd_list_element *unsethistlist;
 261
 262 /* Chain containing all defined maintenance subcommands. */
 263
 264 #if MAINTENANCE_CMDS
 265 struct cmd_list_element *maintenancelist;
 266 #endif
 267
 268 /* Chain containing all defined "maintenance info" subcommands. */
 269
 270 #if MAINTENANCE_CMDS
 271 struct cmd_list_element *maintenanceinfolist;
 272 #endif
 273
 274 /* Chain containing all defined "maintenance print" subcommands. */
 275
 276 #if MAINTENANCE_CMDS
 277 struct cmd_list_element *maintenanceprintlist;
 278 #endif
 279
 280 struct cmd_list_element *setprintlist;
 281
 282 struct cmd_list_element *showprintlist;
 283
 284 struct cmd_list_element *setchecklist;
 285
 286 struct cmd_list_element *showchecklist;
 287
 288 /* stdio stream that command input is being read from.  Set to stdin normally.
 289    Set by source_command to the file we are sourcing.  Set to NULL if we are
 290    executing a user-defined command or interacting via a GUI.  */
 291
 292 FILE *instream;
 293
 294 /* Current working directory.  */
 295
 296 char *current_directory;
 297
 298 /* The directory name is actually stored here (usually).  */
 299 char gdb_dirbuf[1024];
 300
 301 /* Function to call before reading a command, if nonzero.
 302    The function receives two args: an input stream,
 303    and a prompt string.  */
 304
 305 void (*window_hook) PARAMS ((FILE *, char *));
 306
 307 int epoch_interface;
 308 int xgdb_verbose;
 309
 310 /* gdb prints this when reading a command interactively */
 311 static char *prompt;
 312
 313 /* Buffer used for reading command lines, and the size
 314    allocated for it so far.  */
 315
 316 char *line;
 317 int linesize = 100;
 318
 319 /* Nonzero if the current command is modified by "server ".  This
 320    affects things like recording into the command history, comamnds
 321    repeating on RETURN, etc.  This is so a user interface (emacs, GUI,
 322    whatever) can issue its own commands and also send along commands
 323    from the user, and have the user not notice that the user interface
 324    is issuing commands too.  */
 325 int server_command;
 326
 327 /* Baud rate specified for talking to serial target systems.  Default
 328    is left as -1, so targets can choose their own defaults.  */
 329 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
 330    or (unsigned int)-1.  This is a Bad User Interface.  */
 331
 332 int baud_rate = -1;
 333
 334 /* Timeout limit for response from target. */
 335
 336 int remote_timeout = 20;        /* Set default to 20 */
 337
 338 /* Non-zero tells remote* modules to output debugging info.  */
 339
 340 int remote_debug = 0;
 341
 342 /* Level of control structure.  */
 343 static int control_level;
 344
 345 /* Structure for arguments to user defined functions.  */
 346 #define MAXUSERARGS 10
 347 struct user_args
 348 {
 349   struct user_args *next;
 350   struct
 351     {
 352       char *arg;
 353       int len;
 354     } a[MAXUSERARGS];
 355   int count;
 356 } *user_args;
 357
 358 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT.  */
 359
 360 #ifndef STOP_SIGNAL
 361 #ifdef SIGTSTP
 362 #define STOP_SIGNAL SIGTSTP
 363 static void stop_sig PARAMS ((int));
 364 #endif
 365 #endif
 366
 367 /* Some System V have job control but not sigsetmask(). */
 368 #if !defined (HAVE_SIGSETMASK)
 369 #if !defined (USG)
 370 #define HAVE_SIGSETMASK 1
 371 #else
 372 #define HAVE_SIGSETMASK 0
 373 #endif
 374 #endif
 375
 376 #if 0 == (HAVE_SIGSETMASK)
 377 #define sigsetmask(n)
 378 #endif
 379
 380 /* Hooks for alternate command interfaces.  */
 381
 382 /* Called after most modules have been initialized, but before taking users
 383    command file.  */
 384
 385 void (*init_ui_hook) PARAMS ((void));
 386
 387 /* Called instead of command_loop at top level.  Can be invoked via
 388    return_to_top_level.  */
 389
 390 void (*command_loop_hook) PARAMS ((void));
 391
 392
 393 /* Called instead of fputs for all output.  */
 394
 395 void (*fputs_unfiltered_hook) PARAMS ((const char *linebuffer, FILE *stream));
 396
 397 /* Called when the target says something to the host, which may
 398    want to appear in a different window. */
 399
 400 void (*target_output_hook) PARAMS ((char *));
 401
 402 /* Called from print_frame_info to list the line we stopped in.  */
 403
 404 void (*print_frame_info_listing_hook) PARAMS ((struct symtab *s, int line,
 405                                                int stopline, int noerror));
 406 /* Replaces most of query.  */
 407
 408 int (*query_hook) PARAMS ((const char *, va_list));
 409
 410 /* Called from gdb_flush to flush output.  */
 411
 412 void (*flush_hook) PARAMS ((FILE *stream));
 413
 414 /* These three functions support getting lines of text from the user.  They
 415    are used in sequence.  First readline_begin_hook is called with a text
 416    string that might be (for example) a message for the user to type in a
 417    sequence of commands to be executed at a breakpoint.  If this function
 418    calls back to a GUI, it might take this opportunity to pop up a text
 419    interaction window with this message.  Next, readline_hook is called
 420    with a prompt that is emitted prior to collecting the user input.
 421    It can be called multiple times.  Finally, readline_end_hook is called
 422    to notify the GUI that we are done with the interaction window and it
 423    can close it. */
 424
 425 void (*readline_begin_hook) PARAMS ((char *, ...));
 426 char * (*readline_hook) PARAMS ((char *));
 427 void (*readline_end_hook) PARAMS ((void));
 428
 429 /* Called as appropriate to notify the interface of the specified breakpoint
 430    conditions.  */
 431
 432 void (*create_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 433 void (*delete_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 434 void (*modify_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 435
 436 /* Called during long calculations to allow GUI to repair window damage, and to
 437    check for stop buttons, etc... */
 438
 439 void (*interactive_hook) PARAMS ((void));
 440
 441 /* Called when the registers have changed, as a hint to a GUI
 442    to minimize window update. */
 443
 444 void (*registers_changed_hook) PARAMS ((void));
 445
 446 /* Called when going to wait for the target.  Usually allows the GUI to run
 447    while waiting for target events.  */
 448
 449 int (*target_wait_hook) PARAMS ((int pid, struct target_waitstatus *status));
 450
 451 /* Used by UI as a wrapper around command execution.  May do various things
 452    like enabling/disabling buttons, etc...  */
 453
 454 void (*call_command_hook) PARAMS ((struct cmd_list_element *c, char *cmd,
 455                                    int from_tty));
 456
 457
 458 /* Takes control from error ().  Typically used to prevent longjmps out of the
 459    middle of the GUI.  Usually used in conjunction with a catch routine.  */
 460
 461 NORETURN void (*error_hook) PARAMS ((void)) ATTR_NORETURN;
 462
 463 \f
 464 /* Where to go for return_to_top_level (RETURN_ERROR).  */
 465 jmp_buf error_return;
 466 /* Where to go for return_to_top_level (RETURN_QUIT).  */
 467 jmp_buf quit_return;
 468
 469 /* Return for reason REASON.  This generally gets back to the command
 470    loop, but can be caught via catch_errors.  */
 471
 472 NORETURN void
 473 return_to_top_level (reason)
 474      enum return_reason reason;
 475 {
 476   quit_flag = 0;
 477   immediate_quit = 0;
 478
 479   /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
 480      I can think of a reason why that is vital, though).  */
 481   bpstat_clear_actions(stop_bpstat);    /* Clear queued breakpoint commands */
 482
 483   disable_current_display ();
 484   do_cleanups (ALL_CLEANUPS);
 485
 486   if (annotation_level > 1)
 487     switch (reason)
 488       {
 489       case RETURN_QUIT:
 490         annotate_quit ();
 491         break;
 492       case RETURN_ERROR:
 493         annotate_error ();
 494         break;
 495       }
 496
 497   (NORETURN void) longjmp
 498     (reason == RETURN_ERROR ? error_return : quit_return, 1);
 499 }
 500
 501 /* Call FUNC with arg ARGS, catching any errors.  If there is no
 502    error, return the value returned by FUNC.  If there is an error,
 503    print ERRSTRING, print the specific error message, then return
 504    zero.
 505
 506    Must not be called with immediate_quit in effect (bad things might
 507    happen, say we got a signal in the middle of a memcpy to quit_return).
 508    This is an OK restriction; with very few exceptions immediate_quit can
 509    be replaced by judicious use of QUIT.
 510
 511    MASK specifies what to catch; it is normally set to
 512    RETURN_MASK_ALL, if for no other reason than that the code which
 513    calls catch_errors might not be set up to deal with a quit which
 514    isn't caught.  But if the code can deal with it, it generally
 515    should be RETURN_MASK_ERROR, unless for some reason it is more
 516    useful to abort only the portion of the operation inside the
 517    catch_errors.  Note that quit should return to the command line
 518    fairly quickly, even if some further processing is being done.  */
 519
 520 int
 521 catch_errors (func, args, errstring, mask)
 522      int (*func) PARAMS ((char *));
 523      PTR args;
 524      char *errstring;
 525      return_mask mask;
 526 {
 527   jmp_buf saved_error;
 528   jmp_buf saved_quit;
 529   jmp_buf tmp_jmp;
 530   int val;
 531   struct cleanup *saved_cleanup_chain;
 532   char *saved_error_pre_print;
 533   char *saved_quit_pre_print;
 534
 535   saved_cleanup_chain = save_cleanups ();
 536   saved_error_pre_print = error_pre_print;
 537   saved_quit_pre_print = quit_pre_print;
 538
 539   if (mask & RETURN_MASK_ERROR)
 540     {
 541       memcpy ((char *)saved_error, (char *)error_return, sizeof (jmp_buf));
 542       error_pre_print = errstring;
 543     }
 544   if (mask & RETURN_MASK_QUIT)
 545     {
 546       memcpy (saved_quit, quit_return, sizeof (jmp_buf));
 547       quit_pre_print = errstring;
 548     }
 549
 550   if (setjmp (tmp_jmp) == 0)
 551     {
 552       if (mask & RETURN_MASK_ERROR)
 553         memcpy (error_return, tmp_jmp, sizeof (jmp_buf));
 554       if (mask & RETURN_MASK_QUIT)
 555         memcpy (quit_return, tmp_jmp, sizeof (jmp_buf));
 556       val = (*func) (args);
 557     }
 558   else
 559     val = 0;
 560
 561   restore_cleanups (saved_cleanup_chain);
 562
 563   if (mask & RETURN_MASK_ERROR)
 564     {
 565       memcpy (error_return, saved_error, sizeof (jmp_buf));
 566       error_pre_print = saved_error_pre_print;
 567     }
 568   if (mask & RETURN_MASK_QUIT)
 569     {
 570       memcpy (quit_return, saved_quit, sizeof (jmp_buf));
 571       quit_pre_print = saved_quit_pre_print;
 572     }
 573   return val;
 574 }
 575
 576 /* Handler for SIGHUP.  */
 577
 578 static void
 579 disconnect (signo)
 580 int signo;
 581 {
 582   catch_errors (quit_cover, NULL,
 583                 "Could not kill the program being debugged", RETURN_MASK_ALL);
 584   signal (SIGHUP, SIG_DFL);
 585   kill (getpid (), SIGHUP);
 586 }
 587
 588 /* Just a little helper function for disconnect().  */
 589
 590 static int
 591 quit_cover (s)
 592 char *s;
 593 {
 594   caution = 0;          /* Throw caution to the wind -- we're exiting.
 595                            This prevents asking the user dumb questions.  */
 596   quit_command((char *)0, 0);
 597   return 0;
 598 }
 599 \f
 600 /* Line number we are currently in in a file which is being sourced.  */
 601 static int source_line_number;
 602
 603 /* Name of the file we are sourcing.  */
 604 static char *source_file_name;
 605
 606 /* Buffer containing the error_pre_print used by the source stuff.
 607    Malloc'd.  */
 608 static char *source_error;
 609 static int source_error_allocated;
 610
 611 /* Something to glom on to the start of error_pre_print if source_file_name
 612    is set.  */
 613 static char *source_pre_error;
 614
 615 /* Clean up on error during a "source" command (or execution of a
 616    user-defined command).  */
 617
 618 static void
 619 source_cleanup (stream)
 620      FILE *stream;
 621 {
 622   /* Restore the previous input stream.  */
 623   instream = stream;
 624 }
 625
 626 /* Read commands from STREAM.  */
 627 void
 628 read_command_file (stream)
 629      FILE *stream;
 630 {
 631   struct cleanup *cleanups;
 632
 633   cleanups = make_cleanup (source_cleanup, instream);
 634   instream = stream;
 635   command_loop ();
 636   do_cleanups (cleanups);
 637 }
 638 \f
 639 extern void init_proc PARAMS ((void));
 640
 641 void (*pre_init_ui_hook) PARAMS ((void));
 642
 643 void
 644 gdb_init ()
 645 {
 646   if (pre_init_ui_hook)
 647     pre_init_ui_hook ();
 648
 649   /* Run the init function of each source file */
 650
 651   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 652   current_directory = gdb_dirbuf;
 653
 654   init_cmd_lists ();    /* This needs to be done first */
 655   initialize_targets (); /* Setup target_terminal macros for utils.c */
 656   initialize_utils ();  /* Make errors and warnings possible */
 657   initialize_all_files ();
 658   init_main ();         /* But that omits this file!  Do it now */
 659   init_signals ();
 660
 661   init_proc ();
 662
 663   /* We need a default language for parsing expressions, so simple things like
 664      "set width 0" won't fail if no language is explicitly set in a config file
 665      or implicitly set by reading an executable during startup. */
 666   set_language (language_c);
 667   expected_language = current_language; /* don't warn about the change.  */
 668
 669   if (init_ui_hook)
 670     init_ui_hook ();
 671 }
 672
 673 /* Allocate, initialize a new command line structure for one of the
 674    control commands (if/while).  */
 675
 676 static struct command_line *
 677 build_command_line (type, args)
 678      enum command_control_type type;
 679      char *args;
 680 {
 681   struct command_line *cmd;
 682
 683   if (args == NULL)
 684     error ("if/while commands require arguments.\n");
 685
 686   cmd = (struct command_line *)xmalloc (sizeof (struct command_line));
 687   cmd->next = NULL;
 688   cmd->control_type = type;
 689
 690   cmd->body_count = 1;
 691   cmd->body_list
 692     = (struct command_line **)xmalloc (sizeof (struct command_line *)
 693                                        * cmd->body_count);
 694   memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
 695   cmd->line = savestring (args, strlen (args));
 696   return cmd;
 697 }
 698
 699 /* Build and return a new command structure for the control commands
 700    such as "if" and "while".  */
 701
 702 static struct command_line *
 703 get_command_line (type, arg)
 704      enum command_control_type type;
 705      char *arg;
 706 {
 707   struct command_line *cmd;
 708   struct cleanup *old_chain = NULL;
 709
 710   /* Allocate and build a new command line structure.  */
 711   cmd = build_command_line (type, arg);
 712
 713   old_chain = make_cleanup (free_command_lines, &cmd);
 714
 715   /* Read in the body of this command.  */
 716   if (recurse_read_control_structure (cmd) == invalid_control)
 717     {
 718       warning ("error reading in control structure\n");
 719       do_cleanups (old_chain);
 720       return NULL;
 721     }
 722
 723   discard_cleanups (old_chain);
 724   return cmd;
 725 }
 726
 727 /* Recursively print a command (including full control structures).  */
 728 void
 729 print_command_line (cmd, depth)
 730      struct command_line *cmd;
 731      unsigned int depth;
 732 {
 733   unsigned int i;
 734
 735   if (depth)
 736     {
 737       for (i = 0; i < depth; i++)
 738         fputs_filtered ("  ", gdb_stdout);
 739     }
 740
 741   /* A simple command, print it and return.  */
 742   if (cmd->control_type == simple_control)
 743     {
 744       fputs_filtered (cmd->line, gdb_stdout);
 745       fputs_filtered ("\n", gdb_stdout);
 746       return;
 747     }
 748
 749   /* loop_continue to jump to the start of a while loop, print it
 750      and return. */
 751   if (cmd->control_type == continue_control)
 752     {
 753       fputs_filtered ("loop_continue\n", gdb_stdout);
 754       return;
 755     }
 756
 757   /* loop_break to break out of a while loop, print it and return.  */
 758   if (cmd->control_type == break_control)
 759     {
 760       fputs_filtered ("loop_break\n", gdb_stdout);
 761       return;
 762     }
 763
 764   /* A while command.  Recursively print its subcommands before returning.  */
 765   if (cmd->control_type == while_control)
 766     {
 767       struct command_line *list;
 768       fputs_filtered ("while ", gdb_stdout);
 769       fputs_filtered (cmd->line, gdb_stdout);
 770       fputs_filtered ("\n", gdb_stdout);
 771       list = *cmd->body_list;
 772       while (list)
 773         {
 774           print_command_line (list, depth + 1);
 775           list = list->next;
 776         }
 777     }
 778
 779   /* An if command.  Recursively print both arms before returning.  */
 780   if (cmd->control_type == if_control)
 781     {
 782       fputs_filtered ("if ", gdb_stdout);
 783       fputs_filtered (cmd->line, gdb_stdout);
 784       fputs_filtered ("\n", gdb_stdout);
 785       /* The true arm. */
 786       print_command_line (cmd->body_list[0], depth + 1);
 787
 788       /* Show the false arm if it exists.  */
 789       if (cmd->body_count == 2)
 790           {
 791             if (depth)
 792               {
 793                 for (i = 0; i < depth; i++)
 794                   fputs_filtered ("  ", gdb_stdout);
 795               }
 796             fputs_filtered ("else\n", gdb_stdout);
 797             print_command_line (cmd->body_list[1], depth + 1);
 798           }
 799       if (depth)
 800         {
 801           for (i = 0; i < depth; i++)
 802             fputs_filtered ("  ", gdb_stdout);
 803         }
 804       fputs_filtered ("end\n", gdb_stdout);
 805     }
 806 }
 807
 808 /* Execute the command in CMD.  */
 809
 810 enum command_control_type
 811 execute_control_command (cmd)
 812      struct command_line *cmd;
 813 {
 814   struct expression *expr;
 815   struct command_line *current;
 816   struct cleanup *old_chain = 0;
 817   value_ptr val;
 818   int loop;
 819   enum command_control_type ret;
 820   char *new_line;
 821
 822   switch (cmd->control_type)
 823     {
 824     case simple_control:
 825       /* A simple command, execute it and return.  */
 826       new_line = insert_args (cmd->line);
 827       if (!new_line)
 828         return invalid_control;
 829       old_chain = make_cleanup (free_current_contents, &new_line);
 830       execute_command (new_line, 0);
 831       ret = cmd->control_type;
 832       break;
 833
 834     case continue_control:
 835     case break_control:
 836       /* Return for "continue", and "break" so we can either
 837          continue the loop at the top, or break out.  */
 838       ret = cmd->control_type;
 839       break;
 840
 841     case while_control:
 842       {
 843         /* Parse the loop control expression for the while statement.  */
 844         new_line = insert_args (cmd->line);
 845         if (!new_line)
 846           return invalid_control;
 847         old_chain = make_cleanup (free_current_contents, &new_line);
 848         expr = parse_expression (new_line);
 849         make_cleanup (free_current_contents, &expr);
 850
 851         ret = simple_control;
 852         loop = 1;
 853
 854         /* Keep iterating so long as the expression is true.  */
 855         while (loop == 1)
 856           {
 857             QUIT;
 858
 859             /* Evaluate the expression.  */
 860             val = evaluate_expression (expr);
 861
 862             /* If the value is false, then break out of the loop.  */
 863             if (!value_true (val))
 864               break;
 865
 866             /* Execute the body of the while statement.  */
 867             current = *cmd->body_list;
 868             while (current)
 869               {
 870                 ret = execute_control_command (current);
 871
 872                 /* If we got an error, or a "break" command, then stop
 873                    looping.  */
 874                 if (ret == invalid_control || ret == break_control)
 875                   {
 876                     loop = 0;
 877                     break;
 878                   }
 879
 880                 /* If we got a "continue" command, then restart the loop
 881                    at this point.  */
 882                 if (ret == continue_control)
 883                   break;
 884
 885                 /* Get the next statement.  */
 886                 current = current->next;
 887               }
 888           }
 889
 890         /* Reset RET so that we don't recurse the break all the way down.  */
 891         if (ret == break_control)
 892           ret = simple_control;
 893
 894         break;
 895       }
 896
 897     case if_control:
 898       {
 899         new_line = insert_args (cmd->line);
 900         if (!new_line)
 901           return invalid_control;
 902         old_chain = make_cleanup (free_current_contents, &new_line);
 903         /* Parse the conditional for the if statement.  */
 904         expr = parse_expression (new_line);
 905         make_cleanup (free_current_contents, &expr);
 906
 907         current = NULL;
 908         ret = simple_control;
 909
 910         /* Evaluate the conditional.  */
 911         val = evaluate_expression (expr);
 912
 913         /* Choose which arm to take commands from based on the value of the
 914            conditional expression.  */
 915         if (value_true (val))
 916           current = *cmd->body_list;
 917         else if (cmd->body_count == 2)
 918           current = *(cmd->body_list + 1);
 919
 920         /* Execute commands in the given arm.  */
 921         while (current)
 922           {
 923             ret = execute_control_command (current);
 924
 925             /* If we got an error, get out.  */
 926             if (ret != simple_control)
 927               break;
 928
 929             /* Get the next statement in the body.  */
 930             current = current->next;
 931           }
 932
 933         break;
 934       }
 935
 936     default:
 937       warning ("Invalid control type in command structure.");
 938       return invalid_control;
 939     }
 940
 941   if (old_chain)
 942     do_cleanups (old_chain);
 943
 944   return ret;
 945 }
 946
 947 /* "while" command support.  Executes a body of statements while the
 948    loop condition is nonzero.  */
 949
 950 static void
 951 while_command (arg, from_tty)
 952      char *arg;
 953      int from_tty;
 954 {
 955   struct command_line *command = NULL;
 956
 957   control_level = 1;
 958   command = get_command_line (while_control, arg);
 959
 960   if (command == NULL)
 961     return;
 962
 963   execute_control_command (command);
 964   free_command_lines (&command);
 965 }
 966
 967 /* "if" command support.  Execute either the true or false arm depending
 968    on the value of the if conditional.  */
 969
 970 static void
 971 if_command (arg, from_tty)
 972      char *arg;
 973      int from_tty;
 974 {
 975   struct command_line *command = NULL;
 976
 977   control_level = 1;
 978   command = get_command_line (if_control, arg);
 979
 980   if (command == NULL)
 981     return;
 982
 983   execute_control_command (command);
 984   free_command_lines (&command);
 985 }
 986
 987 /* Cleanup */
 988 static void
 989 arg_cleanup ()
 990 {
 991   struct user_args *oargs = user_args;
 992   if (!user_args)
 993     fatal ("Internal error, arg_cleanup called with no user args.\n");
 994
 995   user_args = user_args->next;
 996   free (oargs);
 997 }
 998
 999 /* Bind the incomming arguments for a user defined command to
1000    $arg0, $arg1 ... $argMAXUSERARGS.  */
1001
1002 static struct cleanup *
1003 setup_user_args (p)
1004      char *p;
1005 {
1006   struct user_args *args;
1007   struct cleanup *old_chain;
1008   unsigned int arg_count = 0;
1009
1010   args = (struct user_args *)xmalloc (sizeof (struct user_args));
1011   memset (args, 0, sizeof (struct user_args));
1012
1013   args->next = user_args;
1014   user_args = args;
1015
1016   old_chain = make_cleanup (arg_cleanup, 0);
1017
1018   if (p == NULL)
1019     return old_chain;
1020
1021   while (*p)
1022     {
1023       char *start_arg;
1024
1025       if (arg_count >= MAXUSERARGS)
1026         {
1027           error ("user defined function may only have %d arguments.\n",
1028                  MAXUSERARGS);
1029           return old_chain;
1030         }
1031
1032       /* Strip whitespace.  */
1033       while (*p == ' ' || *p == '\t')
1034         p++;
1035
1036       /* P now points to an argument.  */
1037       start_arg = p;
1038       user_args->a[arg_count].arg = p;
1039
1040       /* Get to the end of this argument.  */
1041       while (*p && *p != ' ' && *p != '\t')
1042         p++;
1043
1044       user_args->a[arg_count].len = p - start_arg;
1045       arg_count++;
1046       user_args->count++;
1047     }
1048   return old_chain;
1049 }
1050
1051 /* Given character string P, return a point to the first argument ($arg),
1052    or NULL if P contains no arguments.  */
1053
1054 static char *
1055 locate_arg (p)
1056      char *p;
1057 {
1058   while ((p = strchr (p, '$')))
1059     {
1060       if (strncmp (p, "$arg", 4) == 0 && isdigit (p[4]))
1061         return p;
1062       p++;
1063     }
1064   return NULL;
1065 }
1066
1067 /* Insert the user defined arguments stored in user_arg into the $arg
1068    arguments found in line, with the updated copy being placed into nline.  */
1069
1070 static char *
1071 insert_args (line)
1072      char *line;
1073 {
1074   char *p, *save_line, *new_line;
1075   unsigned len, i;
1076
1077   /* First we need to know how much memory to allocate for the new line.  */
1078   save_line = line;
1079   len = 0;
1080   while ((p = locate_arg (line)))
1081     {
1082       len += p - line;
1083       i = p[4] - '0';
1084
1085       if (i >= user_args->count)
1086         {
1087           error ("Missing argument %d in user function.\n", i);
1088           return NULL;
1089         }
1090       len += user_args->a[i].len;
1091       line = p + 5;
1092     }
1093
1094   /* Don't forget the tail.  */
1095   len += strlen (line);
1096
1097   /* Allocate space for the new line and fill it in.  */
1098   new_line = (char *)xmalloc (len + 1);
1099   if (new_line == NULL)
1100     return NULL;
1101
1102   /* Restore pointer to beginning of old line.  */
1103   line = save_line;
1104
1105   /* Save pointer to beginning of new line.  */
1106   save_line = new_line;
1107
1108   while ((p = locate_arg (line)))
1109     {
1110       int i, len;
1111
1112       memcpy (new_line, line, p - line);
1113       new_line += p - line;
1114       i = p[4] - '0';
1115
1116       len = user_args->a[i].len;
1117       if (len)
1118         {
1119           memcpy (new_line, user_args->a[i].arg, len);
1120           new_line += len;
1121         }
1122       line = p + 5;
1123     }
1124   /* Don't forget the tail.  */
1125   strcpy (new_line, line);
1126
1127   /* Return a pointer to the beginning of the new line.  */
1128   return save_line;
1129 }
1130
1131 void
1132 execute_user_command (c, args)
1133      struct cmd_list_element *c;
1134      char *args;
1135 {
1136   register struct command_line *cmdlines;
1137   struct cleanup *old_chain;
1138   enum command_control_type ret;
1139
1140   old_chain = setup_user_args (args);
1141
1142   cmdlines = c->user_commands;
1143   if (cmdlines == 0)
1144     /* Null command */
1145     return;
1146
1147   /* Set the instream to 0, indicating execution of a
1148      user-defined function.  */
1149   old_chain = make_cleanup (source_cleanup, instream);
1150   instream = (FILE *) 0;
1151   while (cmdlines)
1152     {
1153       ret = execute_control_command (cmdlines);
1154       if (ret != simple_control && ret != break_control)
1155         {
1156           warning ("Error in control structure.\n");
1157           break;
1158         }
1159       cmdlines = cmdlines->next;
1160     }
1161   do_cleanups (old_chain);
1162 }
1163
1164 /* Execute the line P as a command.
1165    Pass FROM_TTY as second argument to the defining function.  */
1166
1167 void
1168 execute_command (p, from_tty)
1169      char *p;
1170      int from_tty;
1171 {
1172   register struct cmd_list_element *c;
1173   register enum language flang;
1174   static int warned = 0;
1175   /* FIXME: These should really be in an appropriate header file */
1176   extern FILE *serial_logfp;
1177   extern void serial_log_command PARAMS ((const char *));
1178
1179   free_all_values ();
1180
1181   /* This can happen when command_line_input hits end of file.  */
1182   if (p == NULL)
1183       return;
1184
1185   if (serial_logfp != NULL)
1186     serial_log_command (p);
1187
1188   while (*p == ' ' || *p == '\t') p++;
1189   if (*p)
1190     {
1191       char *arg;
1192
1193       c = lookup_cmd (&p, cmdlist, "", 0, 1);
1194       /* Pass null arg rather than an empty one.  */
1195       arg = *p ? p : 0;
1196
1197       /* Clear off trailing whitespace, except for set and complete command.  */
1198       if (arg && c->type != set_cmd && c->function.cfunc != complete_command)
1199         {
1200           p = arg + strlen (arg) - 1;
1201           while (p >= arg && (*p == ' ' || *p == '\t'))
1202             p--;
1203           *(p + 1) = '\0';
1204         }
1205
1206       /* If this command has been hooked, run the hook first. */
1207       if (c->hook)
1208         execute_user_command (c->hook, (char *)0);
1209
1210       if (c->class == class_user)
1211         execute_user_command (c, arg);
1212       else if (c->type == set_cmd || c->type == show_cmd)
1213         do_setshow_command (arg, from_tty & caution, c);
1214       else if (c->function.cfunc == NO_FUNCTION)
1215         error ("That is not a command, just a help topic.");
1216       else if (call_command_hook)
1217         call_command_hook (c, arg, from_tty & caution);
1218       else
1219         (*c->function.cfunc) (arg, from_tty & caution);
1220    }
1221
1222   /* Tell the user if the language has changed (except first time).  */
1223   if (current_language != expected_language)
1224   {
1225     if (language_mode == language_mode_auto) {
1226       language_info (1);        /* Print what changed.  */
1227     }
1228     warned = 0;
1229   }
1230
1231   /* Warn the user if the working language does not match the
1232      language of the current frame.  Only warn the user if we are
1233      actually running the program, i.e. there is a stack. */
1234   /* FIXME:  This should be cacheing the frame and only running when
1235      the frame changes.  */
1236
1237   if (target_has_stack)
1238     {
1239       flang = get_frame_language ();
1240       if (!warned
1241           && flang != language_unknown
1242           && flang != current_language->la_language)
1243         {
1244           printf_filtered ("%s\n", lang_frame_mismatch_warn);
1245           warned = 1;
1246         }
1247     }
1248 }
1249
1250 /* ARGSUSED */
1251 static void
1252 command_loop_marker (foo)
1253      int foo;
1254 {
1255 }
1256
1257 /* Read commands from `instream' and execute them
1258    until end of file or error reading instream.  */
1259
1260 void
1261 command_loop ()
1262 {
1263   struct cleanup *old_chain;
1264   char *command;
1265   int stdin_is_tty = ISATTY (stdin);
1266   long time_at_cmd_start;
1267 #ifdef HAVE_SBRK
1268   long space_at_cmd_start;
1269 #endif
1270   extern int display_time;
1271   extern int display_space;
1272
1273   while (instream && !feof (instream))
1274     {
1275       if (window_hook && instream == stdin)
1276         (*window_hook) (instream, prompt);
1277
1278       quit_flag = 0;
1279       if (instream == stdin && stdin_is_tty)
1280         reinitialize_more_filter ();
1281       old_chain = make_cleanup (command_loop_marker, 0);
1282       command = command_line_input (instream == stdin ? prompt : (char *) NULL,
1283                                     instream == stdin, "prompt");
1284       if (command == 0)
1285         return;
1286
1287       time_at_cmd_start = get_run_time ();
1288
1289       if (display_space)
1290         {
1291 #ifdef HAVE_SBRK
1292           extern char **environ;
1293           char *lim = (char *) sbrk (0);
1294
1295           space_at_cmd_start = (long) (lim - (char *) &environ);
1296 #endif
1297         }
1298
1299       execute_command (command, instream == stdin);
1300       /* Do any commands attached to breakpoint we stopped at.  */
1301       bpstat_do_actions (&stop_bpstat);
1302       do_cleanups (old_chain);
1303
1304       if (display_time)
1305         {
1306           long cmd_time = get_run_time () - time_at_cmd_start;
1307
1308           printf_unfiltered ("Command execution time: %ld.%06ld\n",
1309                              cmd_time / 1000000, cmd_time % 1000000);
1310         }
1311
1312       if (display_space)
1313         {
1314 #ifdef HAVE_SBRK
1315           extern char **environ;
1316           char *lim = (char *) sbrk (0);
1317           long space_now = lim - (char *) &environ;
1318           long space_diff = space_now - space_at_cmd_start;
1319
1320           printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
1321                              space_now,
1322                              (space_diff >= 0 ? '+' : '-'),
1323                              space_diff);
1324 #endif
1325         }
1326     }
1327 }
1328 \f
1329 /* Commands call this if they do not want to be repeated by null lines.  */
1330
1331 void
1332 dont_repeat ()
1333 {
1334   if (server_command)
1335     return;
1336
1337   /* If we aren't reading from standard input, we are saving the last
1338      thing read from stdin in line and don't want to delete it.  Null lines
1339      won't repeat here in any case.  */
1340   if (instream == stdin)
1341     *line = 0;
1342 }
1343 \f
1344 /* Read a line from the stream "instream" without command line editing.
1345
1346    It prints PRROMPT once at the start.
1347    Action is compatible with "readline", e.g. space for the result is
1348    malloc'd and should be freed by the caller.
1349
1350    A NULL return means end of file.  */
1351 char *
1352 gdb_readline (prrompt)
1353      char *prrompt;
1354 {
1355   int c;
1356   char *result;
1357   int input_index = 0;
1358   int result_size = 80;
1359
1360   if (prrompt)
1361     {
1362       /* Don't use a _filtered function here.  It causes the assumed
1363          character position to be off, since the newline we read from
1364          the user is not accounted for.  */
1365       fputs_unfiltered (prrompt, gdb_stdout);
1366 #ifdef MPW
1367       /* Move to a new line so the entered line doesn't have a prompt
1368          on the front of it. */
1369       fputs_unfiltered ("\n", gdb_stdout);
1370 #endif /* MPW */
1371       gdb_flush (gdb_stdout);
1372     }
1373
1374   result = (char *) xmalloc (result_size);
1375
1376   while (1)
1377     {
1378       /* Read from stdin if we are executing a user defined command.
1379          This is the right thing for prompt_for_continue, at least.  */
1380       c = fgetc (instream ? instream : stdin);
1381
1382       if (c == EOF)
1383         {
1384           if (input_index > 0)
1385             /* The last line does not end with a newline.  Return it, and
1386                if we are called again fgetc will still return EOF and
1387                we'll return NULL then.  */
1388             break;
1389           free (result);
1390           return NULL;
1391         }
1392
1393       if (c == '\n')
1394         break;
1395
1396       result[input_index++] = c;
1397       while (input_index >= result_size)
1398         {
1399           result_size *= 2;
1400           result = (char *) xrealloc (result, result_size);
1401         }
1402     }
1403
1404   result[input_index++] = '\0';
1405   return result;
1406 }
1407
1408 /* Variables which control command line editing and history
1409    substitution.  These variables are given default values at the end
1410    of this file.  */
1411 static int command_editing_p;
1412 static int history_expansion_p;
1413 static int write_history_p;
1414 static int history_size;
1415 static char *history_filename;
1416
1417 /* readline uses the word breaks for two things:
1418    (1) In figuring out where to point the TEXT parameter to the
1419    rl_completion_entry_function.  Since we don't use TEXT for much,
1420    it doesn't matter a lot what the word breaks are for this purpose, but
1421    it does affect how much stuff M-? lists.
1422    (2) If one of the matches contains a word break character, readline
1423    will quote it.  That's why we switch between
1424    gdb_completer_word_break_characters and
1425    gdb_completer_command_word_break_characters.  I'm not sure when
1426    we need this behavior (perhaps for funky characters in C++ symbols?).  */
1427
1428 /* Variables which are necessary for fancy command line editing.  */
1429 char *gdb_completer_word_break_characters =
1430   " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1431
1432 /* When completing on command names, we remove '-' from the list of
1433    word break characters, since we use it in command names.  If the
1434    readline library sees one in any of the current completion strings,
1435    it thinks that the string needs to be quoted and automatically supplies
1436    a leading quote. */
1437 char *gdb_completer_command_word_break_characters =
1438   " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
1439
1440 /* Characters that can be used to quote completion strings.  Note that we
1441    can't include '"' because the gdb C parser treats such quoted sequences
1442    as strings. */
1443 char *gdb_completer_quote_characters =
1444   "'";
1445
1446 /* Functions that are used as part of the fancy command line editing.  */
1447
1448 /* This can be used for functions which don't want to complete on symbols
1449    but don't want to complete on anything else either.  */
1450 /* ARGSUSED */
1451 char **
1452 noop_completer (text, prefix)
1453      char *text;
1454      char *prefix;
1455 {
1456   return NULL;
1457 }
1458
1459 /* Complete on filenames.  */
1460 char **
1461 filename_completer (text, word)
1462      char *text;
1463      char *word;
1464 {
1465   /* From readline.  */
1466   extern char *filename_completion_function ();
1467   int subsequent_name;
1468   char **return_val;
1469   int return_val_used;
1470   int return_val_alloced;
1471
1472   return_val_used = 0;
1473   /* Small for testing.  */
1474   return_val_alloced = 1;
1475   return_val = (char **) xmalloc (return_val_alloced * sizeof (char *));
1476
1477   subsequent_name = 0;
1478   while (1)
1479     {
1480       char *p;
1481       p = filename_completion_function (text, subsequent_name);
1482       if (return_val_used >= return_val_alloced)
1483         {
1484           return_val_alloced *= 2;
1485           return_val =
1486             (char **) xrealloc (return_val,
1487                                 return_val_alloced * sizeof (char *));
1488         }
1489       if (p == NULL)
1490         {
1491           return_val[return_val_used++] = p;
1492           break;
1493         }
1494       /* Like emacs, don't complete on old versions.  Especially useful
1495          in the "source" command.  */
1496       if (p[strlen (p) - 1] == '~')
1497         continue;
1498
1499       {
1500         char *q;
1501         if (word == text)
1502           /* Return exactly p.  */
1503           return_val[return_val_used++] = p;
1504         else if (word > text)
1505           {
1506             /* Return some portion of p.  */
1507             q = xmalloc (strlen (p) + 5);
1508             strcpy (q, p + (word - text));
1509             return_val[return_val_used++] = q;
1510             free (p);
1511           }
1512         else
1513           {
1514             /* Return some of TEXT plus p.  */
1515             q = xmalloc (strlen (p) + (text - word) + 5);
1516             strncpy (q, word, text - word);
1517             q[text - word] = '\0';
1518             strcat (q, p);
1519             return_val[return_val_used++] = q;
1520             free (p);
1521           }
1522       }
1523       subsequent_name = 1;
1524     }
1525 #if 0
1526   /* There is no way to do this just long enough to affect quote inserting
1527      without also affecting the next completion.  This should be fixed in
1528      readline.  FIXME.  */
1529   /* Insure that readline does the right thing
1530      with respect to inserting quotes.  */
1531   rl_completer_word_break_characters = "";
1532 #endif
1533   return return_val;
1534 }
1535
1536 /* Here are some useful test cases for completion.  FIXME: These should
1537    be put in the test suite.  They should be tested with both M-? and TAB.
1538
1539    "show output-" "radix"
1540    "show output" "-radix"
1541    "p" ambiguous (commands starting with p--path, print, printf, etc.)
1542    "p "  ambiguous (all symbols)
1543    "info t foo" no completions
1544    "info t " no completions
1545    "info t" ambiguous ("info target", "info terminal", etc.)
1546    "info ajksdlfk" no completions
1547    "info ajksdlfk " no completions
1548    "info" " "
1549    "info " ambiguous (all info commands)
1550    "p \"a" no completions (string constant)
1551    "p 'a" ambiguous (all symbols starting with a)
1552    "p b-a" ambiguous (all symbols starting with a)
1553    "p b-" ambiguous (all symbols)
1554    "file Make" "file" (word break hard to screw up here)
1555    "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1556    */
1557
1558 /* Generate completions one by one for the completer.  Each time we are
1559    called return another potential completion to the caller.
1560    line_completion just completes on commands or passes the buck to the
1561    command's completer function, the stuff specific to symbol completion
1562    is in make_symbol_completion_list.
1563
1564    TEXT is the caller's idea of the "word" we are looking at.
1565
1566    MATCHES is the number of matches that have currently been collected from
1567    calling this completion function.  When zero, then we need to initialize,
1568    otherwise the initialization has already taken place and we can just
1569    return the next potential completion string.
1570
1571    LINE_BUFFER is available to be looked at; it contains the entire text
1572    of the line.  POINT is the offset in that line of the cursor.  You
1573    should pretend that the line ends at POINT.
1574
1575    Returns NULL if there are no more completions, else a pointer to a string
1576    which is a possible completion, it is the caller's responsibility to
1577    free the string.  */
1578
1579 static char *
1580 line_completion_function (text, matches, line_buffer, point)
1581      char *text;
1582      int matches;
1583      char *line_buffer;
1584      int point;
1585 {
1586   static char **list = (char **)NULL;           /* Cache of completions */
1587   static int index;                             /* Next cached completion */
1588   char *output = NULL;
1589   char *tmp_command, *p;
1590   /* Pointer within tmp_command which corresponds to text.  */
1591   char *word;
1592   struct cmd_list_element *c, *result_list;
1593
1594   if (matches == 0)
1595     {
1596       /* The caller is beginning to accumulate a new set of completions, so
1597          we need to find all of them now, and cache them for returning one at
1598          a time on future calls. */
1599
1600       if (list)
1601         {
1602           /* Free the storage used by LIST, but not by the strings inside.
1603              This is because rl_complete_internal () frees the strings. */
1604           free ((PTR)list);
1605         }
1606       list = 0;
1607       index = 0;
1608
1609       /* Choose the default set of word break characters to break completions.
1610          If we later find out that we are doing completions on command strings
1611          (as opposed to strings supplied by the individual command completer
1612          functions, which can be any string) then we will switch to the
1613          special word break set for command strings, which leaves out the
1614          '-' character used in some commands.  */
1615
1616       rl_completer_word_break_characters =
1617           gdb_completer_word_break_characters;
1618
1619       /* Decide whether to complete on a list of gdb commands or on symbols. */
1620       tmp_command = (char *) alloca (point + 1);
1621       p = tmp_command;
1622
1623       strncpy (tmp_command, line_buffer, point);
1624       tmp_command[point] = '\0';
1625       /* Since text always contains some number of characters leading up
1626          to point, we can find the equivalent position in tmp_command
1627          by subtracting that many characters from the end of tmp_command.  */
1628       word = tmp_command + point - strlen (text);
1629
1630       if (point == 0)
1631         {
1632           /* An empty line we want to consider ambiguous; that is, it
1633              could be any command.  */
1634           c = (struct cmd_list_element *) -1;
1635           result_list = 0;
1636         }
1637       else
1638         {
1639           c = lookup_cmd_1 (&p, cmdlist, &result_list, 1);
1640         }
1641
1642       /* Move p up to the next interesting thing.  */
1643       while (*p == ' ' || *p == '\t')
1644         {
1645           p++;
1646         }
1647
1648       if (!c)
1649         {
1650           /* It is an unrecognized command.  So there are no
1651              possible completions.  */
1652           list = NULL;
1653         }
1654       else if (c == (struct cmd_list_element *) -1)
1655         {
1656           char *q;
1657
1658           /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1659              doesn't advance over that thing itself.  Do so now.  */
1660           q = p;
1661           while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
1662             ++q;
1663           if (q != tmp_command + point)
1664             {
1665               /* There is something beyond the ambiguous
1666                  command, so there are no possible completions.  For
1667                  example, "info t " or "info t foo" does not complete
1668                  to anything, because "info t" can be "info target" or
1669                  "info terminal".  */
1670               list = NULL;
1671             }
1672           else
1673             {
1674               /* We're trying to complete on the command which was ambiguous.
1675                  This we can deal with.  */
1676               if (result_list)
1677                 {
1678                   list = complete_on_cmdlist (*result_list->prefixlist, p,
1679                                               word);
1680                 }
1681               else
1682                 {
1683                   list = complete_on_cmdlist (cmdlist, p, word);
1684                 }
1685               /* Insure that readline does the right thing with respect to
1686                  inserting quotes.  */
1687               rl_completer_word_break_characters =
1688                 gdb_completer_command_word_break_characters;
1689             }
1690         }
1691       else
1692         {
1693           /* We've recognized a full command.  */
1694
1695           if (p == tmp_command + point)
1696             {
1697               /* There is no non-whitespace in the line beyond the command.  */
1698
1699               if (p[-1] == ' ' || p[-1] == '\t')
1700                 {
1701                   /* The command is followed by whitespace; we need to complete
1702                      on whatever comes after command.  */
1703                   if (c->prefixlist)
1704                     {
1705                       /* It is a prefix command; what comes after it is
1706                          a subcommand (e.g. "info ").  */
1707                       list = complete_on_cmdlist (*c->prefixlist, p, word);
1708
1709                       /* Insure that readline does the right thing
1710                          with respect to inserting quotes.  */
1711                       rl_completer_word_break_characters =
1712                         gdb_completer_command_word_break_characters;
1713                     }
1714                   else if (c->enums)
1715                     {
1716                       list = complete_on_enum (c->enums, p, word);
1717                       rl_completer_word_break_characters =
1718                         gdb_completer_command_word_break_characters;
1719                     }
1720                   else
1721                     {
1722                       /* It is a normal command; what comes after it is
1723                          completed by the command's completer function.  */
1724                       list = (*c->completer) (p, word);
1725                     }
1726                 }
1727               else
1728                 {
1729                   /* The command is not followed by whitespace; we need to
1730                      complete on the command itself.  e.g. "p" which is a
1731                      command itself but also can complete to "print", "ptype"
1732                      etc.  */
1733                   char *q;
1734
1735                   /* Find the command we are completing on.  */
1736                   q = p;
1737                   while (q > tmp_command)
1738                     {
1739                       if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
1740                         --q;
1741                       else
1742                         break;
1743                     }
1744
1745                   list = complete_on_cmdlist (result_list, q, word);
1746
1747                   /* Insure that readline does the right thing
1748                      with respect to inserting quotes.  */
1749                   rl_completer_word_break_characters =
1750                     gdb_completer_command_word_break_characters;
1751                 }
1752             }
1753           else
1754             {
1755               /* There is non-whitespace beyond the command.  */
1756
1757               if (c->prefixlist && !c->allow_unknown)
1758                 {
1759                   /* It is an unrecognized subcommand of a prefix command,
1760                      e.g. "info adsfkdj".  */
1761                   list = NULL;
1762                 }
1763               else if (c->enums)
1764                 {
1765                   list = complete_on_enum (c->enums, p, word);
1766                 }
1767               else
1768                 {
1769                   /* It is a normal command.  */
1770                   list = (*c->completer) (p, word);
1771                 }
1772             }
1773         }
1774     }
1775
1776   /* If we found a list of potential completions during initialization then
1777      dole them out one at a time.  The vector of completions is NULL
1778      terminated, so after returning the last one, return NULL (and continue
1779      to do so) each time we are called after that, until a new list is
1780      available. */
1781
1782   if (list)
1783     {
1784       output = list[index];
1785       if (output)
1786         {
1787           index++;
1788         }
1789     }
1790
1791 #if 0
1792   /* Can't do this because readline hasn't yet checked the word breaks
1793      for figuring out whether to insert a quote.  */
1794   if (output == NULL)
1795     /* Make sure the word break characters are set back to normal for the
1796        next time that readline tries to complete something.  */
1797     rl_completer_word_break_characters =
1798       gdb_completer_word_break_characters;
1799 #endif
1800
1801   return (output);
1802 }
1803
1804 /* Line completion interface function for readline.  */
1805
1806 static char *
1807 readline_line_completion_function (text, matches)
1808      char *text;
1809      int matches;
1810 {
1811   return line_completion_function (text, matches, rl_line_buffer, rl_point);
1812 }
1813
1814 /* Skip over a possibly quoted word (as defined by the quote characters
1815    and word break characters the completer uses).  Returns pointer to the
1816    location after the "word". */
1817
1818 char *
1819 skip_quoted (str)
1820      char *str;
1821 {
1822   char quote_char = '\0';
1823   char *scan;
1824
1825   for (scan = str; *scan != '\0'; scan++)
1826     {
1827       if (quote_char != '\0')
1828         {
1829           /* Ignore everything until the matching close quote char */
1830           if (*scan == quote_char)
1831             {
1832               /* Found matching close quote. */
1833               scan++;
1834               break;
1835             }
1836         }
1837       else if (strchr (gdb_completer_quote_characters, *scan))
1838         {
1839           /* Found start of a quoted string. */
1840           quote_char = *scan;
1841         }
1842       else if (strchr (gdb_completer_word_break_characters, *scan))
1843         {
1844           break;
1845         }
1846     }
1847   return (scan);
1848 }
1849
1850 \f
1851 #ifdef STOP_SIGNAL
1852 static void
1853 stop_sig (signo)
1854 int signo;
1855 {
1856 #if STOP_SIGNAL == SIGTSTP
1857   signal (SIGTSTP, SIG_DFL);
1858   sigsetmask (0);
1859   kill (getpid (), SIGTSTP);
1860   signal (SIGTSTP, stop_sig);
1861 #else
1862   signal (STOP_SIGNAL, stop_sig);
1863 #endif
1864   printf_unfiltered ("%s", prompt);
1865   gdb_flush (gdb_stdout);
1866
1867   /* Forget about any previous command -- null line now will do nothing.  */
1868   dont_repeat ();
1869 }
1870 #endif /* STOP_SIGNAL */
1871
1872 /* Initialize signal handlers. */
1873 static void
1874 do_nothing (signo)
1875 int signo;
1876 {
1877 }
1878
1879 static void
1880 init_signals ()
1881 {
1882   signal (SIGINT, request_quit);
1883
1884   /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
1885      to the inferior and breakpoints will be ignored.  */
1886 #ifdef SIGTRAP
1887   signal (SIGTRAP, SIG_DFL);
1888 #endif
1889
1890   /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
1891      passed to the inferior, which we don't want.  It would be
1892      possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
1893      on BSD4.3 systems using vfork, that can affect the
1894      GDB process as well as the inferior (the signal handling tables
1895      might be in memory, shared between the two).  Since we establish
1896      a handler for SIGQUIT, when we call exec it will set the signal
1897      to SIG_DFL for us.  */
1898   signal (SIGQUIT, do_nothing);
1899   if (signal (SIGHUP, do_nothing) != SIG_IGN)
1900     signal (SIGHUP, disconnect);
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 == 0)
2991     perror_with_name (file);
2992
2993   make_cleanup (fclose, stream);
2994
2995   old_lines.old_line = source_line_number;
2996   old_lines.old_file = source_file_name;
2997   old_lines.old_pre_error = source_pre_error;
2998   old_lines.old_error_pre_print = error_pre_print;
2999   make_cleanup (source_cleanup_lines, &old_lines);
3000   source_line_number = 0;
3001   source_file_name = file;
3002   source_pre_error = error_pre_print == NULL ? "" : error_pre_print;
3003   source_pre_error = savestring (source_pre_error, strlen (source_pre_error));
3004   make_cleanup (free, source_pre_error);
3005   /* This will get set every time we read a line.  So it won't stay "" for
3006      long.  */
3007   error_pre_print = "";
3008
3009   needed_length = strlen (source_file_name) + strlen (source_pre_error) + 80;
3010   if (source_error_allocated < needed_length)
3011     {
3012       source_error_allocated *= 2;
3013       if (source_error_allocated < needed_length)
3014         source_error_allocated = needed_length;
3015       if (source_error == NULL)
3016         source_error = xmalloc (source_error_allocated);
3017       else
3018         source_error = xrealloc (source_error, source_error_allocated);
3019     }
3020
3021   read_command_file (stream);
3022
3023   do_cleanups (old_cleanups);
3024 }
3025
3026 /* ARGSUSED */
3027 static void
3028 echo_command (text, from_tty)
3029      char *text;
3030      int from_tty;
3031 {
3032   char *p = text;
3033   register int c;
3034
3035   if (text)
3036     while ((c = *p++) != '\0')
3037       {
3038         if (c == '\\')
3039           {
3040             /* \ at end of argument is used after spaces
3041                so they won't be lost.  */
3042             if (*p == 0)
3043               return;
3044
3045             c = parse_escape (&p);
3046             if (c >= 0)
3047               printf_filtered ("%c", c);
3048           }
3049         else
3050           printf_filtered ("%c", c);
3051       }
3052
3053   /* Force this output to appear now.  */
3054   wrap_here ("");
3055   gdb_flush (gdb_stdout);
3056 }
3057
3058 /* ARGSUSED */
3059 static void
3060 dont_repeat_command (ignored, from_tty)
3061      char *ignored;
3062      int from_tty;
3063 {
3064   *line = 0;            /* Can't call dont_repeat here because we're not
3065                            necessarily reading from stdin.  */
3066 }
3067 \f
3068 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3069
3070 /* Functions to manipulate the endianness of the target.  */
3071
3072 #ifndef TARGET_BYTE_ORDER_DEFAULT
3073 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
3074 #endif
3075
3076 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
3077
3078 static int target_byte_order_auto = 1;
3079
3080 /* Called if the user enters ``set endian'' without an argument.  */
3081 static void
3082 set_endian (args, from_tty)
3083      char *args;
3084      int from_tty;
3085 {
3086   printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
3087   show_endian (args, from_tty);
3088 }
3089
3090 /* Called by ``set endian big''.  */
3091 static void
3092 set_endian_big (args, from_tty)
3093      char *args;
3094      int from_tty;
3095 {
3096   target_byte_order = BIG_ENDIAN;
3097   target_byte_order_auto = 0;
3098 }
3099
3100 /* Called by ``set endian little''.  */
3101 static void
3102 set_endian_little (args, from_tty)
3103      char *args;
3104      int from_tty;
3105 {
3106   target_byte_order = LITTLE_ENDIAN;
3107   target_byte_order_auto = 0;
3108 }
3109
3110 /* Called by ``set endian auto''.  */
3111 static void
3112 set_endian_auto (args, from_tty)
3113      char *args;
3114      int from_tty;
3115 {
3116   target_byte_order_auto = 1;
3117 }
3118
3119 /* Called by ``show endian''.  */
3120 static void
3121 show_endian (args, from_tty)
3122      char *args;
3123      int from_tty;
3124 {
3125   const char *msg =
3126     (target_byte_order_auto
3127      ? "The target endianness is set automatically (currently %s endian)\n"
3128      : "The target is assumed to be %s endian\n");
3129   printf_unfiltered ((char *) msg, TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
3130 }
3131
3132 #endif /* defined (TARGET_BYTE_ORDER_SELECTABLE) */
3133
3134 /* Set the endianness from a BFD.  */
3135 void
3136 set_endian_from_file (abfd)
3137      bfd *abfd;
3138 {
3139 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3140   int want;
3141
3142   if (bfd_big_endian (abfd))
3143     want = BIG_ENDIAN;
3144   else
3145     want = LITTLE_ENDIAN;
3146   if (target_byte_order_auto)
3147     target_byte_order = want;
3148   else if (target_byte_order != want)
3149     warning ("%s endian file does not match %s endian target.",
3150              want == BIG_ENDIAN ? "big" : "little",
3151              TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
3152
3153 #else /* ! defined (TARGET_BYTE_ORDER_SELECTABLE) */
3154
3155   if (bfd_big_endian (abfd)
3156       ? TARGET_BYTE_ORDER != BIG_ENDIAN
3157       : TARGET_BYTE_ORDER == BIG_ENDIAN)
3158     warning ("%s endian file does not match %s endian target.",
3159              bfd_big_endian (abfd) ? "big" : "little",
3160              TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
3161
3162 #endif /* ! defined (TARGET_BYTE_ORDER_SELECTABLE) */
3163 }
3164 \f
3165 /* Functions to manipulate command line editing control variables.  */
3166
3167 /* Number of commands to print in each call to show_commands.  */
3168 #define Hist_print 10
3169 static void
3170 show_commands (args, from_tty)
3171      char *args;
3172      int from_tty;
3173 {
3174   /* Index for history commands.  Relative to history_base.  */
3175   int offset;
3176
3177   /* Number of the history entry which we are planning to display next.
3178      Relative to history_base.  */
3179   static int num = 0;
3180
3181   /* The first command in the history which doesn't exist (i.e. one more
3182      than the number of the last command).  Relative to history_base.  */
3183   int hist_len;
3184
3185   extern HIST_ENTRY *history_get PARAMS ((int));
3186
3187   /* Print out some of the commands from the command history.  */
3188   /* First determine the length of the history list.  */
3189   hist_len = history_size;
3190   for (offset = 0; offset < history_size; offset++)
3191     {
3192       if (!history_get (history_base + offset))
3193         {
3194           hist_len = offset;
3195           break;
3196         }
3197     }
3198
3199   if (args)
3200     {
3201       if (args[0] == '+' && args[1] == '\0')
3202         /* "info editing +" should print from the stored position.  */
3203         ;
3204       else
3205         /* "info editing <exp>" should print around command number <exp>.  */
3206         num = (parse_and_eval_address (args) - history_base) - Hist_print / 2;
3207     }
3208   /* "show commands" means print the last Hist_print commands.  */
3209   else
3210     {
3211       num = hist_len - Hist_print;
3212     }
3213
3214   if (num < 0)
3215     num = 0;
3216
3217   /* If there are at least Hist_print commands, we want to display the last
3218      Hist_print rather than, say, the last 6.  */
3219   if (hist_len - num < Hist_print)
3220     {
3221       num = hist_len - Hist_print;
3222       if (num < 0)
3223         num = 0;
3224     }
3225
3226   for (offset = num; offset < num + Hist_print && offset < hist_len; offset++)
3227     {
3228       printf_filtered ("%5d  %s\n", history_base + offset,
3229               (history_get (history_base + offset))->line);
3230     }
3231
3232   /* The next command we want to display is the next one that we haven't
3233      displayed yet.  */
3234   num += Hist_print;
3235
3236   /* If the user repeats this command with return, it should do what
3237      "show commands +" does.  This is unnecessary if arg is null,
3238      because "show commands +" is not useful after "show commands".  */
3239   if (from_tty && args)
3240     {
3241       args[0] = '+';
3242       args[1] = '\0';
3243     }
3244 }
3245
3246 /* Called by do_setshow_command.  */
3247 /* ARGSUSED */
3248 static void
3249 set_history_size_command (args, from_tty, c)
3250      char *args;
3251      int from_tty;
3252      struct cmd_list_element *c;
3253 {
3254   if (history_size == INT_MAX)
3255     unstifle_history ();
3256   else if (history_size >= 0)
3257     stifle_history (history_size);
3258   else
3259     {
3260       history_size = INT_MAX;
3261       error ("History size must be non-negative");
3262     }
3263 }
3264
3265 /* ARGSUSED */
3266 static void
3267 set_history (args, from_tty)
3268      char *args;
3269      int from_tty;
3270 {
3271   printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
3272   help_list (sethistlist, "set history ", -1, gdb_stdout);
3273 }
3274
3275 /* ARGSUSED */
3276 static void
3277 show_history (args, from_tty)
3278      char *args;
3279      int from_tty;
3280 {
3281   cmd_show_list (showhistlist, from_tty, "");
3282 }
3283
3284 int info_verbose = 0;           /* Default verbose msgs off */
3285
3286 /* Called by do_setshow_command.  An elaborate joke.  */
3287 /* ARGSUSED */
3288 static void
3289 set_verbose (args, from_tty, c)
3290      char *args;
3291      int from_tty;
3292      struct cmd_list_element *c;
3293 {
3294   char *cmdname = "verbose";
3295   struct cmd_list_element *showcmd;
3296
3297   showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
3298
3299   if (info_verbose)
3300     {
3301       c->doc = "Set verbose printing of informational messages.";
3302       showcmd->doc = "Show verbose printing of informational messages.";
3303     }
3304   else
3305     {
3306       c->doc = "Set verbosity.";
3307       showcmd->doc = "Show verbosity.";
3308     }
3309 }
3310
3311 static void
3312 float_handler (signo)
3313 int signo;
3314 {
3315   /* This message is based on ANSI C, section 4.7.  Note that integer
3316      divide by zero causes this, so "float" is a misnomer.  */
3317   signal (SIGFPE, float_handler);
3318   error ("Erroneous arithmetic operation.");
3319 }
3320
3321 \f
3322 static void
3323 init_cmd_lists ()
3324 {
3325   cmdlist = NULL;
3326   infolist = NULL;
3327   enablelist = NULL;
3328   disablelist = NULL;
3329   deletelist = NULL;
3330   enablebreaklist = NULL;
3331   setlist = NULL;
3332   unsetlist = NULL;
3333   showlist = NULL;
3334 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3335   endianlist = NULL;
3336 #endif
3337   sethistlist = NULL;
3338   showhistlist = NULL;
3339   unsethistlist = NULL;
3340 #if MAINTENANCE_CMDS
3341   maintenancelist = NULL;
3342   maintenanceinfolist = NULL;
3343   maintenanceprintlist = NULL;
3344 #endif
3345   setprintlist = NULL;
3346   showprintlist = NULL;
3347   setchecklist = NULL;
3348   showchecklist = NULL;
3349 }
3350
3351 /* Init the history buffer.  Note that we are called after the init file(s)
3352  * have been read so that the user can change the history file via his
3353  * .gdbinit file (for instance).  The GDBHISTFILE environment variable
3354  * overrides all of this.
3355  */
3356
3357 void
3358 init_history()
3359 {
3360   char *tmpenv;
3361
3362   tmpenv = getenv ("HISTSIZE");
3363   if (tmpenv)
3364     history_size = atoi (tmpenv);
3365   else if (!history_size)
3366     history_size = 256;
3367
3368   stifle_history (history_size);
3369
3370   tmpenv = getenv ("GDBHISTFILE");
3371   if (tmpenv)
3372     history_filename = savestring (tmpenv, strlen(tmpenv));
3373   else if (!history_filename) {
3374     /* We include the current directory so that if the user changes
3375        directories the file written will be the same as the one
3376        that was read.  */
3377     history_filename = concat (current_directory, "/.gdb_history", NULL);
3378   }
3379   read_history (history_filename);
3380 }
3381
3382 static void
3383 init_main ()
3384 {
3385   struct cmd_list_element *c;
3386
3387 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3388
3389   add_prefix_cmd ("endian", class_support, set_endian,
3390                   "Set endianness of target.",
3391                   &endianlist, "set endian ", 0, &setlist);
3392   add_cmd ("big", class_support, set_endian_big,
3393            "Set target as being big endian.", &endianlist);
3394   add_cmd ("little", class_support, set_endian_little,
3395            "Set target as being little endian.", &endianlist);
3396   add_cmd ("auto", class_support, set_endian_auto,
3397            "Select target endianness automatically.", &endianlist);
3398   add_cmd ("endian", class_support, show_endian,
3399            "Show endianness of target.", &showlist);
3400
3401 #endif /* defined (TARGET_BYTE_ORDER_SELECTABLE) */
3402
3403 #ifdef DEFAULT_PROMPT
3404   prompt = savestring (DEFAULT_PROMPT, strlen(DEFAULT_PROMPT));
3405 #else
3406   prompt = savestring ("(gdb) ", 6);
3407 #endif
3408
3409   /* Set the important stuff up for command editing.  */
3410   command_editing_p = 1;
3411   history_expansion_p = 0;
3412   write_history_p = 0;
3413
3414   /* Setup important stuff for command line editing.  */
3415   rl_completion_entry_function = (int (*)()) readline_line_completion_function;
3416   rl_completer_word_break_characters = gdb_completer_word_break_characters;
3417   rl_completer_quote_characters = gdb_completer_quote_characters;
3418   rl_readline_name = "gdb";
3419
3420   /* Define the classes of commands.
3421      They will appear in the help list in the reverse of this order.  */
3422
3423   add_cmd ("internals", class_maintenance, NO_FUNCTION,
3424            "Maintenance commands.\n\
3425 Some gdb commands are provided just for use by gdb maintainers.\n\
3426 These commands are subject to frequent change, and may not be as\n\
3427 well documented as user commands.",
3428            &cmdlist);
3429   add_cmd ("obscure", class_obscure, NO_FUNCTION, "Obscure features.", &cmdlist);
3430   add_cmd ("aliases", class_alias, NO_FUNCTION, "Aliases of other commands.", &cmdlist);
3431   add_cmd ("user-defined", class_user, NO_FUNCTION, "User-defined commands.\n\
3432 The commands in this class are those defined by the user.\n\
3433 Use the \"define\" command to define a command.", &cmdlist);
3434   add_cmd ("support", class_support, NO_FUNCTION, "Support facilities.", &cmdlist);
3435   add_cmd ("status", class_info, NO_FUNCTION, "Status inquiries.", &cmdlist);
3436   add_cmd ("files", class_files, NO_FUNCTION, "Specifying and examining files.", &cmdlist);
3437   add_cmd ("breakpoints", class_breakpoint, NO_FUNCTION, "Making program stop at certain points.", &cmdlist);
3438   add_cmd ("data", class_vars, NO_FUNCTION, "Examining data.", &cmdlist);
3439   add_cmd ("stack", class_stack, NO_FUNCTION, "Examining the stack.\n\
3440 The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
3441 counting from zero for the innermost (currently executing) frame.\n\n\
3442 At any time gdb identifies one frame as the \"selected\" frame.\n\
3443 Variable lookups are done with respect to the selected frame.\n\
3444 When the program being debugged stops, gdb selects the innermost frame.\n\
3445 The commands below can be used to select other frames by number or address.",
3446            &cmdlist);
3447   add_cmd ("running", class_run, NO_FUNCTION, "Running the program.", &cmdlist);
3448
3449   add_com ("pwd", class_files, pwd_command,
3450            "Print working directory.  This is used for your program as well.");
3451   c = add_cmd ("cd", class_files, cd_command,
3452            "Set working directory to DIR for debugger and program being debugged.\n\
3453 The change does not take effect for the program being debugged\n\
3454 until the next time it is started.", &cmdlist);
3455   c->completer = filename_completer;
3456
3457   add_show_from_set
3458     (add_set_cmd ("prompt", class_support, var_string, (char *)&prompt,
3459            "Set gdb's prompt",
3460            &setlist),
3461      &showlist);
3462
3463   add_com ("echo", class_support, echo_command,
3464            "Print a constant string.  Give string as argument.\n\
3465 C escape sequences may be used in the argument.\n\
3466 No newline is added at the end of the argument;\n\
3467 use \"\\n\" if you want a newline to be printed.\n\
3468 Since leading and trailing whitespace are ignored in command arguments,\n\
3469 if you want to print some you must use \"\\\" before leading whitespace\n\
3470 to be printed or after trailing whitespace.");
3471   add_com ("document", class_support, document_command,
3472            "Document a user-defined command.\n\
3473 Give command name as argument.  Give documentation on following lines.\n\
3474 End with a line of just \"end\".");
3475   add_com ("define", class_support, define_command,
3476            "Define a new command name.  Command name is argument.\n\
3477 Definition appears on following lines, one command per line.\n\
3478 End with a line of just \"end\".\n\
3479 Use the \"document\" command to give documentation for the new command.\n\
3480 Commands defined in this way may have up to ten arguments.");
3481
3482 #ifdef __STDC__
3483   c = add_cmd ("source", class_support, source_command,
3484            "Read commands from a file named FILE.\n\
3485 Note that the file \"" GDBINIT_FILENAME "\" is read automatically in this way\n\
3486 when gdb is started.", &cmdlist);
3487 #else
3488   /* Punt file name, we can't help it easily.  */
3489   c = add_cmd ("source", class_support, source_command,
3490            "Read commands from a file named FILE.\n\
3491 Note that the file \".gdbinit\" is read automatically in this way\n\
3492 when gdb is started.", &cmdlist);
3493 #endif
3494   c->completer = filename_completer;
3495
3496   add_com ("quit", class_support, quit_command, "Exit gdb.");
3497   add_com ("help", class_support, help_command, "Print list of commands.");
3498   add_com_alias ("q", "quit", class_support, 1);
3499   add_com_alias ("h", "help", class_support, 1);
3500
3501   add_com ("dont-repeat", class_support, dont_repeat_command, "Don't repeat this command.\n\
3502 Primarily used inside of user-defined commands that should not be repeated when\n\
3503 hitting return.");
3504
3505   c = add_set_cmd ("verbose", class_support, var_boolean, (char *)&info_verbose,
3506                    "Set ",
3507                    &setlist),
3508   add_show_from_set (c, &showlist);
3509   c->function.sfunc = set_verbose;
3510   set_verbose (NULL, 0, c);
3511
3512   add_show_from_set
3513     (add_set_cmd ("editing", class_support, var_boolean, (char *)&command_editing_p,
3514            "Set editing of command lines as they are typed.\n\
3515 Use \"on\" to enable to enable the editing, and \"off\" to disable it.\n\
3516 Without an argument, command line editing is enabled.  To edit, use\n\
3517 EMACS-like or VI-like commands like control-P or ESC.", &setlist),
3518      &showlist);
3519
3520   add_prefix_cmd ("history", class_support, set_history,
3521                   "Generic command for setting command history parameters.",
3522                   &sethistlist, "set history ", 0, &setlist);
3523   add_prefix_cmd ("history", class_support, show_history,
3524                   "Generic command for showing command history parameters.",
3525                   &showhistlist, "show history ", 0, &showlist);
3526
3527   add_show_from_set
3528     (add_set_cmd ("expansion", no_class, var_boolean, (char *)&history_expansion_p,
3529            "Set history expansion on command input.\n\
3530 Without an argument, history expansion is enabled.", &sethistlist),
3531      &showhistlist);
3532
3533   add_show_from_set
3534     (add_set_cmd ("save", no_class, var_boolean, (char *)&write_history_p,
3535            "Set saving of the history record on exit.\n\
3536 Use \"on\" to enable to enable the saving, and \"off\" to disable it.\n\
3537 Without an argument, saving is enabled.", &sethistlist),
3538      &showhistlist);
3539
3540   c = add_set_cmd ("size", no_class, var_integer, (char *)&history_size,
3541                    "Set the size of the command history, \n\
3542 ie. the number of previous commands to keep a record of.", &sethistlist);
3543   add_show_from_set (c, &showhistlist);
3544   c->function.sfunc = set_history_size_command;
3545
3546   add_show_from_set
3547     (add_set_cmd ("filename", no_class, var_filename, (char *)&history_filename,
3548            "Set the filename in which to record the command history\n\
3549  (the list of previous commands of which a record is kept).", &sethistlist),
3550      &showhistlist);
3551
3552   add_show_from_set
3553     (add_set_cmd ("confirm", class_support, var_boolean,
3554                   (char *)&caution,
3555                   "Set whether to confirm potentially dangerous operations.",
3556                   &setlist),
3557      &showlist);
3558
3559   add_prefix_cmd ("info", class_info, info_command,
3560         "Generic command for showing things about the program being debugged.",
3561                   &infolist, "info ", 0, &cmdlist);
3562   add_com_alias ("i", "info", class_info, 1);
3563
3564   add_com ("complete", class_obscure, complete_command,
3565            "List the completions for the rest of the line as a command.");
3566
3567   add_prefix_cmd ("show", class_info, show_command,
3568                   "Generic command for showing things about the debugger.",
3569                   &showlist, "show ", 0, &cmdlist);
3570   /* Another way to get at the same thing.  */
3571   add_info ("set", show_command, "Show all GDB settings.");
3572
3573   add_cmd ("commands", no_class, show_commands,
3574            "Show the history of commands you typed.\n\
3575 You can supply a command number to start with, or a `+' to start after\n\
3576 the previous command number shown.",
3577            &showlist);
3578
3579   add_cmd ("version", no_class, show_version,
3580            "Show what version of GDB this is.", &showlist);
3581
3582   add_com ("while", class_support, while_command,
3583 "Execute nested commands WHILE the conditional expression is non zero.\n\
3584 The conditional expression must follow the word `while' and must in turn be\n\
3585 followed by a new line.  The nested commands must be entered one per line,\n\
3586 and should be terminated by the word `end'.");
3587
3588   add_com ("if", class_support, if_command,
3589 "Execute nested commands once IF the conditional expression is non zero.\n\
3590 The conditional expression must follow the word `if' and must in turn be\n\
3591 followed by a new line.  The nested commands must be entered one per line,\n\
3592 and should be terminated by the word 'else' or `end'.  If an else clause\n\
3593 is used, the same rules apply to its nested commands as to the first ones.");
3594
3595   /* If target is open when baud changes, it doesn't take effect until the
3596      next open (I think, not sure).  */
3597   add_show_from_set (add_set_cmd ("remotebaud", no_class,
3598                                   var_zinteger, (char *)&baud_rate,
3599                                   "Set baud rate for remote serial I/O.\n\
3600 This value is used to set the speed of the serial port when debugging\n\
3601 using remote targets.", &setlist),
3602                      &showlist);
3603
3604   add_show_from_set (
3605     add_set_cmd ("remotedebug", no_class, var_zinteger, (char *)&remote_debug,
3606                    "Set debugging of remote protocol.\n\
3607 When enabled, each packet sent or received with the remote target\n\
3608 is displayed.", &setlist),
3609                      &showlist);
3610
3611   add_show_from_set (
3612     add_set_cmd ("remotetimeout", no_class, var_integer, (char *)&remote_timeout,
3613                    "Set timeout limit to wait for target to respond.\n\
3614 This value is used to set the time limit for gdb to wait for a response\n\
3615 from he target.", &setlist),
3616                      &showlist);
3617 }