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, 2002

   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 "cli/cli-cmds.h"

#include "cli/cli-script.h"

#include "cli/cli-setshow.h"

#include "cli/cli-decode.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"

#include "serial.h"

#include "doublest.h"

#include "gdb_assert.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>

#include "ui-out.h"

#include "cli-out.h"

/* 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 = 0;

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 */

/* 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

/* Hooks for alternate command interfaces.  */

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

   command file.

   If the UI fails to initialize and it wants GDB to continue

   using the default UI, then it should clear this hook before returning. */

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

   throw_exception().  */

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 throw_exception().  */

static SIGJMP_BUF *catch_return;

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

NORETURN void

throw_exception (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 args FUNC_UIOUT and FUNC_ARGS, catching any

   errors.  Set FUNC_CAUGHT to an ``enum return_reason'' if the

   function is aborted (using throw_exception() or zero if the

   function returns normally.  Set FUNC_VAL to the value returned by

   the function or 0 if the function was aborted.

   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? */

static void

catcher (catch_exceptions_ftype *func,

         struct ui_out *func_uiout,

         void *func_args,

         int *func_val,

         enum return_reason *func_caught,

         char *errstring,

         return_mask mask)

{

  SIGJMP_BUF *saved_catch;

  SIGJMP_BUF catch;

  struct cleanup *saved_cleanup_chain;

  char *saved_error_pre_print;

  char *saved_quit_pre_print;

  struct ui_out *saved_uiout;

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

     quit caught, 0 otherwise. */

  int caught;

  /* Return value from FUNC(): Hopefully non-zero. Explicitly set to

     zero if an error quit was caught.  */

  int val;

  /* 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;

  /* Override the global ``struct ui_out'' builder.  */

  saved_uiout = uiout;

  uiout = func_uiout;

  /* 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) (func_uiout, 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, the error/quit messages, and the uiout

     builder, to their original states. */

  restore_cleanups (saved_cleanup_chain);

  uiout = saved_uiout;

  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 or this catcher

     can handle this exception.  The caller analyses the func return

     values.  */

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

    {

      *func_val = val;

      *func_caught = caught;

      return;

    }

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

     event to the next containing catch_errors(). */

  throw_exception (caught);

}

int

catch_exceptions (struct ui_out *uiout,

                  catch_exceptions_ftype *func,

                  void *func_args,

                  char *errstring,

                  return_mask mask)

{

  int val;

  enum return_reason caught;

  catcher (func, uiout, func_args, &val, &caught, errstring, mask);

  gdb_assert (val >= 0);

  gdb_assert (caught <= 0);

  if (caught < 0)

    return caught;

  return val;

}

struct catch_errors_args

{

  catch_errors_ftype *func;

  void *func_args;

};

int

do_catch_errors (struct ui_out *uiout, void *data)

{

  struct catch_errors_args *args = data;

  return args->func (args->func_args);

}

int

catch_errors (catch_errors_ftype *func, void *func_args, char *errstring,

              return_mask mask)

{

  int val;

  enum return_reason caught;

  struct catch_errors_args args;

  args.func = func;

  args.func_args = func_args;

  catcher (do_catch_errors, uiout, &args, &val, &caught, errstring, mask);

  if (caught != 0)

    return 0;

  return val;

}

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

/* 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 (void *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;

}

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);

}

#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);

}

void (*pre_init_ui_hook) (void);

#ifdef __MSDOS__

void

do_chdir_cleanup (void *old_dir)

{

  chdir (old_dir);

  xfree (old_dir);

}

#endif

/* 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;

  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;

      /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy

         while the is_complete_command(cfunc) test is just plain

         bogus.  They should both be replaced by a test of the form

         c->strip_trailing_white_space_p.  */

      /* NOTE: cagney/2002-02-02: The function.cfunc in the below

         can't be replaced with func.  This is because it is the

         cfunc, and not the func, that has the value that the

         is_complete_command hack is testing for.  */

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

         command.  */

      if (arg

          && c->type != set_cmd

          && !is_complete_command (c))

        {

          p = arg + strlen (arg) - 1;

          while (p >= arg && (*p == ' ' || *p == '\t'))

            p--;

          *(p + 1) = '\0';

        }

      /* If this command has been pre-hooked, run the hook first. */

      execute_cmd_pre_hook (c);

      if (c->flags & DEPRECATED_WARN_USER)

        deprecated_cmd_warning (&line);

      if (c->class == class_user)

        execute_user_command (c, arg);

      else if (c->type == set_cmd || c->type == show_cmd)

        do_setshow_command (arg, from_tty & caution, c);

      else if (!cmd_func_p (c))

        error ("That is not a command, just a help topic.");

      else if (call_command_hook)

        call_command_hook (c, arg, from_tty & caution);

      else

        cmd_func (c, arg, from_tty & caution);

      /* If this command has been post-hooked, run the hook last. */

      execute_cmd_post_hook (c);

    }

  /* Tell the user if the language has changed (except first time).  */

  if (current_language != expected_language)

    {

      if (language_mode == language_mode_auto)

        {

          language_info (1);    /* Print what changed.  */

        }

      warned = 0;

    }

  /* Warn the user if the working language does not match the

     language of the current frame.  Only warn the user if we are

     actually running the program, i.e. there is a stack. */

  /* FIXME:  This should be cacheing the frame and only running when

     the frame changes.  */

  if (target_has_stack)

    {

      flang = get_frame_language ();

      if (!warned

          && flang != language_unknown

          && flang != current_language->la_language)

        {

          printf_filtered ("%s\n", lang_frame_mismatch_warn);

          warned = 1;

        }

    }

}

/* Read commands from `instream' and execute them

   until end of file or error reading instream.  */

void

command_loop (void)

{

  struct cleanup *old_chain;

  char *command;

  int stdin_is_tty = ISATTY (stdin);

  long time_at_cmd_start;

#ifdef HAVE_SBRK

  long space_at_cmd_start = 0;