Subversion Repositories or1k

/* Top level stuff for GDB, the GNU debugger.

   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,

   1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

#include "defs.h"

#include "gdbcmd.h"

#include "call-cmds.h"

#include "symtab.h"

#include "inferior.h"

#include <signal.h>

#include "target.h"

#include "breakpoint.h"

#include "gdbtypes.h"

#include "expression.h"

#include "value.h"

#include "language.h"

#include "terminal.h"           /* For job_control.  */

#include "annotate.h"

#include "completer.h"

#include "top.h"

#include "version.h"

/* readline include files */

#include <readline/readline.h>

#include <readline/history.h>

/* readline defines this.  */

#undef savestring

#include <sys/types.h>

#include <setjmp.h>

#include "event-top.h"

#include "gdb_string.h"

#include "gdb_stat.h"

#include <ctype.h>

#ifdef UI_OUT

#include "ui-out.h"

#include "cli-out.h"

#endif

/* From completer.c */

extern int is_complete_command (void (*func) (char *args, int from_tty));

/* From cli/cli-cmds.c */

extern void init_cmd_lists (void);

extern void init_cli_cmds (void);

extern void execute_user_command (struct cmd_list_element *c, char *args);

/* From cli/cli-setshow.c */

extern void do_setshow_command (char *, int, struct cmd_list_element *);

/* Exported to CLI cli/cli-cmds.c. */

void set_verbose (char *, int, struct cmd_list_element *);

void show_history (char *, int);

void set_history (char *, int);

void show_commands (char *, int);

void do_restore_instream_cleanup (void *stream);

/* Prototypes for local functions */

static void dont_repeat_command (char *, int);

static void init_signals (void);

#ifdef STOP_SIGNAL

static void stop_sig (int);

#endif

static char *readline_line_completion_function (char *, int);

static void init_main (void);

static void float_handler (int);

static void init_signals (void);

static void set_history_size_command (char *, int, struct cmd_list_element *);

static void do_nothing (int);

#ifdef SIGHUP

/* NOTE 1999-04-29: This function will be static again, once we modify

   gdb to use the event loop as the default command loop and we merge

   event-top.c into this file, top.c */

/* static */ int quit_cover (PTR);

static void disconnect (int);

#endif

/* Default command line prompt.  This is overriden in some configs. */

#ifndef DEFAULT_PROMPT

#define DEFAULT_PROMPT  "(gdb) "

#endif

/* Initialization file name for gdb.  This is overridden in some configs.  */

#ifndef GDBINIT_FILENAME

#define GDBINIT_FILENAME        ".gdbinit"

#endif

char gdbinit[] = GDBINIT_FILENAME;

int inhibit_gdbinit = 0;

/* If nonzero, and GDB has been configured to be able to use windows,

   attempt to open them upon startup.  */

int use_windows = 1;

extern char lang_frame_mismatch_warn[];         /* language.c */

/* Flag for whether we want all the "from_tty" gubbish printed.  */

int caution = 1;                /* Default is yes, sigh. */

/* stdio stream that command input is being read from.  Set to stdin normally.

   Set by source_command to the file we are sourcing.  Set to NULL if we are

   executing a user-defined command or interacting via a GUI.  */

FILE *instream;

/* Current working directory.  */

char *current_directory;

/* The directory name is actually stored here (usually).  */

char gdb_dirbuf[1024];

/* Function to call before reading a command, if nonzero.

   The function receives two args: an input stream,

   and a prompt string.  */

void (*window_hook) (FILE *, char *);

int epoch_interface;

int xgdb_verbose;

/* gdb prints this when reading a command interactively */

static char *gdb_prompt_string; /* the global prompt string */

extern char *get_prompt (void); /* access function for prompt string */

/* Buffer used for reading command lines, and the size

   allocated for it so far.  */

char *line;

int linesize = 100;

/* Nonzero if the current command is modified by "server ".  This

   affects things like recording into the command history, commands

   repeating on RETURN, etc.  This is so a user interface (emacs, GUI,

   whatever) can issue its own commands and also send along commands

   from the user, and have the user not notice that the user interface

   is issuing commands too.  */

int server_command;

/* Baud rate specified for talking to serial target systems.  Default

   is left as -1, so targets can choose their own defaults.  */

/* FIXME: This means that "show remotebaud" and gr_files_info can print -1

   or (unsigned int)-1.  This is a Bad User Interface.  */

int baud_rate = -1;

/* Timeout limit for response from target. */

/* The default value has been changed many times over the years.  It

   was originally 5 seconds.  But that was thought to be a long time

   to sit and wait, so it was changed to 2 seconds.  That was thought

   to be plenty unless the connection was going through some terminal

   server or multiplexer or other form of hairy serial connection.

   In mid-1996, remote_timeout was moved from remote.c to top.c and

   it began being used in other remote-* targets.  It appears that the

   default was changed to 20 seconds at that time, perhaps because the

   Hitachi E7000 ICE didn't always respond in a timely manner.

   But if 5 seconds is a long time to sit and wait for retransmissions,

   20 seconds is far worse.  This demonstrates the difficulty of using

   a single variable for all protocol timeouts.

   As remote.c is used much more than remote-e7000.c, it was changed

   back to 2 seconds in 1999. */

int remote_timeout = 2;

/* Non-zero tells remote* modules to output debugging info.  */

int remote_debug = 0;

/* Non-zero means the target is running. Note: this is different from

   saying that there is an active target and we are stopped at a

   breakpoint, for instance. This is a real indicator whether the

   target is off and running, which gdb is doing something else. */

int target_executing = 0;

/* Level of control structure.  */

static int control_level;

/* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT.  */

#ifndef STOP_SIGNAL

#ifdef SIGTSTP

#define STOP_SIGNAL SIGTSTP

static void stop_sig (int);

#endif

#endif

/* Some System V have job control but not sigsetmask(). */

#if !defined (HAVE_SIGSETMASK)

#if !defined (USG)

#define HAVE_SIGSETMASK 1

#else

#define HAVE_SIGSETMASK 0

#endif

#endif

#if 0 == (HAVE_SIGSETMASK)

#define sigsetmask(n)

#endif

/* Hooks for alternate command interfaces.  */

/* Called after most modules have been initialized, but before taking users

   command file.  */

void (*init_ui_hook) (char *argv0);

/* This hook is called from within gdb's many mini-event loops which could

   steal control from a real user interface's event loop. It returns

   non-zero if the user is requesting a detach, zero otherwise. */

int (*ui_loop_hook) (int);

/* Called instead of command_loop at top level.  Can be invoked via

   return_to_top_level.  */

void (*command_loop_hook) (void);

/* Called from print_frame_info to list the line we stopped in.  */

void (*print_frame_info_listing_hook) (struct symtab * s, int line,

                                       int stopline, int noerror);

/* Replaces most of query.  */

int (*query_hook) (const char *, va_list);

/* Replaces most of warning.  */

void (*warning_hook) (const char *, va_list);

/* These three functions support getting lines of text from the user.  They

   are used in sequence.  First readline_begin_hook is called with a text

   string that might be (for example) a message for the user to type in a

   sequence of commands to be executed at a breakpoint.  If this function

   calls back to a GUI, it might take this opportunity to pop up a text

   interaction window with this message.  Next, readline_hook is called

   with a prompt that is emitted prior to collecting the user input.

   It can be called multiple times.  Finally, readline_end_hook is called

   to notify the GUI that we are done with the interaction window and it

   can close it. */

void (*readline_begin_hook) (char *, ...);

char *(*readline_hook) (char *);

void (*readline_end_hook) (void);

/* Called as appropriate to notify the interface of the specified breakpoint

   conditions.  */

void (*create_breakpoint_hook) (struct breakpoint * bpt);

void (*delete_breakpoint_hook) (struct breakpoint * bpt);

void (*modify_breakpoint_hook) (struct breakpoint * bpt);

/* Called as appropriate to notify the interface that we have attached

   to or detached from an already running process. */

void (*attach_hook) (void);

void (*detach_hook) (void);

/* Called during long calculations to allow GUI to repair window damage, and to

   check for stop buttons, etc... */

void (*interactive_hook) (void);

/* Called when the registers have changed, as a hint to a GUI

   to minimize window update. */

void (*registers_changed_hook) (void);

/* Tell the GUI someone changed the register REGNO. -1 means

   that the caller does not know which register changed or

   that several registers have changed (see value_assign). */

void (*register_changed_hook) (int regno);

/* Tell the GUI someone changed LEN bytes of memory at ADDR */

void (*memory_changed_hook) (CORE_ADDR addr, int len);

/* Called when going to wait for the target.  Usually allows the GUI to run

   while waiting for target events.  */

ptid_t (*target_wait_hook) (ptid_t ptid,

                            struct target_waitstatus * status);

/* Used by UI as a wrapper around command execution.  May do various things

   like enabling/disabling buttons, etc...  */

void (*call_command_hook) (struct cmd_list_element * c, char *cmd,

                           int from_tty);

/* Called after a `set' command has finished.  Is only run if the

   `set' command succeeded.  */

void (*set_hook) (struct cmd_list_element * c);

/* Called when the current thread changes.  Argument is thread id.  */

void (*context_hook) (int id);

/* Takes control from error ().  Typically used to prevent longjmps out of the

   middle of the GUI.  Usually used in conjunction with a catch routine.  */

NORETURN void (*error_hook) (void) ATTR_NORETURN;

/* One should use catch_errors rather than manipulating these

   directly.  */

#if defined(HAVE_SIGSETJMP)

#define SIGJMP_BUF              sigjmp_buf

#define SIGSETJMP(buf)          sigsetjmp(buf, 1)

#define SIGLONGJMP(buf,val)     siglongjmp(buf,val)

#else

#define SIGJMP_BUF              jmp_buf

#define SIGSETJMP(buf)          setjmp(buf)

#define SIGLONGJMP(buf,val)     longjmp(buf,val)

#endif

/* Where to go for return_to_top_level.  */

static SIGJMP_BUF *catch_return;

/* Return for reason REASON to the nearest containing catch_errors().  */

NORETURN void

return_to_top_level (enum return_reason reason)

{

  quit_flag = 0;

  immediate_quit = 0;

  /* Perhaps it would be cleaner to do this via the cleanup chain (not sure

     I can think of a reason why that is vital, though).  */

  bpstat_clear_actions (stop_bpstat);   /* Clear queued breakpoint commands */

  disable_current_display ();

  do_cleanups (ALL_CLEANUPS);

  if (event_loop_p && target_can_async_p () && !target_executing)

    do_exec_cleanups (ALL_CLEANUPS);

  if (event_loop_p && sync_execution)

    do_exec_error_cleanups (ALL_CLEANUPS);

  if (annotation_level > 1)

    switch (reason)

      {

      case RETURN_QUIT:

        annotate_quit ();

        break;

      case RETURN_ERROR:

        annotate_error ();

        break;

      }

  /* Jump to the containing catch_errors() call, communicating REASON

     to that call via setjmp's return value.  Note that REASON can't

     be zero, by definition in defs.h. */

  (NORETURN void) SIGLONGJMP (*catch_return, (int) reason);

}

/* Call FUNC with arg ARGS, catching any errors.  If there is no

   error, return the value returned by FUNC.  If there is an error,

   print ERRSTRING, print the specific error message, then return

   zero.

   Must not be called with immediate_quit in effect (bad things might

   happen, say we got a signal in the middle of a memcpy to quit_return).

   This is an OK restriction; with very few exceptions immediate_quit can

   be replaced by judicious use of QUIT.

   MASK specifies what to catch; it is normally set to

   RETURN_MASK_ALL, if for no other reason than that the code which

   calls catch_errors might not be set up to deal with a quit which

   isn't caught.  But if the code can deal with it, it generally

   should be RETURN_MASK_ERROR, unless for some reason it is more

   useful to abort only the portion of the operation inside the

   catch_errors.  Note that quit should return to the command line

   fairly quickly, even if some further processing is being done.  */

/* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with

   error() et.al. could maintain a set of flags that indicate the the

   current state of each of the longjmp buffers.  This would give the

   longjmp code the chance to detect a longjmp botch (before it gets

   to longjmperror()).  Prior to 1999-11-05 this wasn't possible as

   code also randomly used a SET_TOP_LEVEL macro that directly

   initialize the longjmp buffers. */

/* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code

   be consolidated into a single file instead of being distributed

   between utils.c and top.c? */

int

catch_errors (catch_errors_ftype *func, PTR args, char *errstring,

              return_mask mask)

{

  SIGJMP_BUF *saved_catch;

  SIGJMP_BUF catch;

  int val;

  struct cleanup *saved_cleanup_chain;

  char *saved_error_pre_print;

  char *saved_quit_pre_print;

  /* Return value from SIGSETJMP(): enum return_reason if error or

     quit caught, 0 otherwise. */

  int caught;

  /* Override error/quit messages during FUNC. */

  saved_error_pre_print = error_pre_print;

  saved_quit_pre_print = quit_pre_print;

  if (mask & RETURN_MASK_ERROR)

    error_pre_print = errstring;

  if (mask & RETURN_MASK_QUIT)

    quit_pre_print = errstring;

  /* Prevent error/quit during FUNC from calling cleanups established

     prior to here. */

  saved_cleanup_chain = save_cleanups ();

  /* Call FUNC, catching error/quit events. */

  saved_catch = catch_return;

  catch_return = &catch;

  caught = SIGSETJMP (catch);

  if (!caught)

    val = (*func) (args);

  else

    val = 0;

  catch_return = saved_catch;

  /* FIXME: cagney/1999-11-05: A correct FUNC implementation will

     clean things up (restoring the cleanup chain) to the state they

     were just prior to the call.  Unfortunately, many FUNC's are not

     that well behaved.  This could be fixed by adding either a

     do_cleanups call (to cover the problem) or an assertion check to

     detect bad FUNCs code. */

  /* Restore the cleanup chain and error/quit messages to their

     original states. */

  restore_cleanups (saved_cleanup_chain);

  if (mask & RETURN_MASK_QUIT)

    quit_pre_print = saved_quit_pre_print;

  if (mask & RETURN_MASK_ERROR)

    error_pre_print = saved_error_pre_print;

  /* Return normally if no error/quit event occurred. */

  if (!caught)

    return val;

  /* If the caller didn't request that the event be caught, relay the

     event to the next containing catch_errors(). */

  if (!(mask & RETURN_MASK (caught)))

    return_to_top_level (caught);

  /* Tell the caller that an event was caught.

     FIXME: nsd/2000-02-22: When MASK is RETURN_MASK_ALL, the caller

     can't tell what type of event occurred.

     A possible fix is to add a new interface, catch_event(), that

     returns enum return_reason after catching an error or a quit.

     When returning normally, i.e. without catching an error or a

     quit, catch_event() could return RETURN_NORMAL, which would be

     added to enum return_reason.  FUNC would return information

     exclusively via ARGS.

     Alternatively, normal catch_event() could return FUNC's return

     value.  The caller would need to be aware of potential overlap

     with enum return_reason, which could be publicly restricted to

     negative values to simplify return value processing in FUNC and

     in the caller. */

  return 0;

}

struct captured_command_args

  {

    catch_command_errors_ftype *command;

    char *arg;

    int from_tty;

  };

static int

do_captured_command (void *data)

{

  struct captured_command_args *context = data;

  context->command (context->arg, context->from_tty);

  /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call

     isn't needed.  Instead an assertion check could be made that

     simply confirmed that the called function correctly cleaned up

     after itself.  Unfortunately, old code (prior to 1999-11-04) in

     main.c was calling SET_TOP_LEVEL(), calling the command function,

     and then *always* calling do_cleanups().  For the moment we

     remain ``bug compatible'' with that old code..  */

  do_cleanups (ALL_CLEANUPS);

  return 1;

}

int

catch_command_errors (catch_command_errors_ftype * command,

                      char *arg, int from_tty, return_mask mask)

{

  struct captured_command_args args;

  args.command = command;

  args.arg = arg;

  args.from_tty = from_tty;

  return catch_errors (do_captured_command, &args, "", mask);

}

/* Handler for SIGHUP.  */

#ifdef SIGHUP

static void

disconnect (int signo)

{

  catch_errors (quit_cover, NULL,

              "Could not kill the program being debugged", RETURN_MASK_ALL);

  signal (SIGHUP, SIG_DFL);

  kill (getpid (), SIGHUP);

}

/* Just a little helper function for disconnect().  */

/* NOTE 1999-04-29: This function will be static again, once we modify

   gdb to use the event loop as the default command loop and we merge

   event-top.c into this file, top.c */

/* static */ int

quit_cover (PTR s)

{

  caution = 0;                   /* Throw caution to the wind -- we're exiting.

                                   This prevents asking the user dumb questions.  */

  quit_command ((char *) 0, 0);

  return 0;

}

#endif /* defined SIGHUP */

/* Line number we are currently in in a file which is being sourced.  */

/* NOTE 1999-04-29: This variable will be static again, once we modify

   gdb to use the event loop as the default command loop and we merge

   event-top.c into this file, top.c */

/* static */ int source_line_number;

/* Name of the file we are sourcing.  */

/* NOTE 1999-04-29: This variable will be static again, once we modify

   gdb to use the event loop as the default command loop and we merge

   event-top.c into this file, top.c */

/* static */ char *source_file_name;

/* Buffer containing the error_pre_print used by the source stuff.

   Malloc'd.  */

/* NOTE 1999-04-29: This variable will be static again, once we modify

   gdb to use the event loop as the default command loop and we merge

   event-top.c into this file, top.c */

/* static */ char *source_error;

static int source_error_allocated;

/* Something to glom on to the start of error_pre_print if source_file_name

   is set.  */

/* NOTE 1999-04-29: This variable will be static again, once we modify

   gdb to use the event loop as the default command loop and we merge

   event-top.c into this file, top.c */

/* static */ char *source_pre_error;

/* Clean up on error during a "source" command (or execution of a

   user-defined command).  */

void

do_restore_instream_cleanup (void *stream)

{

  /* Restore the previous input stream.  */

  instream = stream;

}

/* Read commands from STREAM.  */

void

read_command_file (FILE *stream)

{

  struct cleanup *cleanups;

  cleanups = make_cleanup (do_restore_instream_cleanup, instream);

  instream = stream;

  command_loop ();

  do_cleanups (cleanups);

}

extern void init_proc (void);

void (*pre_init_ui_hook) (void);

#ifdef __MSDOS__

void

do_chdir_cleanup (void *old_dir)

{

  chdir (old_dir);

  xfree (old_dir);

}

#endif

void

gdb_init (char *argv0)

{

  if (pre_init_ui_hook)

    pre_init_ui_hook ();

  /* Run the init function of each source file */

  getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));

  current_directory = gdb_dirbuf;

#ifdef __MSDOS__

  /* Make sure we return to the original directory upon exit, come

     what may, since the OS doesn't do that for us.  */

  make_final_cleanup (do_chdir_cleanup, xstrdup (current_directory));

#endif

  init_cmd_lists ();            /* This needs to be done first */

  initialize_targets ();        /* Setup target_terminal macros for utils.c */

  initialize_utils ();          /* Make errors and warnings possible */

  initialize_all_files ();

  initialize_current_architecture ();

  init_cli_cmds();

  init_main ();                 /* But that omits this file!  Do it now */

  /* The signal handling mechanism is different depending whether or

     not the async version is run. NOTE: in the future we plan to make

     the event loop be the default engine of gdb, and this difference

     will disappear. */

  if (event_loop_p)

    async_init_signals ();

  else

    init_signals ();

  /* We need a default language for parsing expressions, so simple things like

     "set width 0" won't fail if no language is explicitly set in a config file

     or implicitly set by reading an executable during startup. */

  set_language (language_c);

  expected_language = current_language;         /* don't warn about the change.  */

#ifdef UI_OUT

  /* Install the default UI */

  if (!init_ui_hook)

    {

      uiout = cli_out_new (gdb_stdout);

      /* All the interpreters should have had a look at things by now.

         Initialize the selected interpreter. */

      if (interpreter_p)

        {

          fprintf_unfiltered (gdb_stderr, "Interpreter `%s' unrecognized.\n",

                              interpreter_p);

          exit (1);

        }

    }

#endif

  if (init_ui_hook)

    init_ui_hook (argv0);

}

/* Execute the line P as a command.

   Pass FROM_TTY as second argument to the defining function.  */

void

execute_command (char *p, int from_tty)

{

  register struct cmd_list_element *c;

  register enum language flang;

  static int warned = 0;

  char *line;

  /* FIXME: These should really be in an appropriate header file */

  extern void serial_log_command (const char *);

  free_all_values ();

  /* Force cleanup of any alloca areas if using C alloca instead of

     a builtin alloca.  */

  alloca (0);

  /* This can happen when command_line_input hits end of file.  */

  if (p == NULL)

    return;

  serial_log_command (p);

  while (*p == ' ' || *p == '\t')

    p++;

  if (*p)

    {

      char *arg;

      line = p;

      c = lookup_cmd (&p, cmdlist, "", 0, 1);

      /* If the target is running, we allow only a limited set of

         commands. */

      if (event_loop_p && target_can_async_p () && target_executing)

        if (!strcmp (c->name, "help")

            && !strcmp (c->name, "pwd")

            && !strcmp (c->name, "show")

            && !strcmp (c->name, "stop"))

          error ("Cannot execute this command while the target is running.");

      /* Pass null arg rather than an empty one.  */

      arg = *p ? p : 0;

      /* Clear off trailing whitespace, except for set and complete command.  */

      if (arg

          && c->type != set_cmd

          && !is_complete_command (c->function.cfunc))