Subversion Repositories or1k

/* GDB hooks for TUI.
 
   Copyright 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.  */
 
/* FIXME: cagney/2002-02-28: The GDB coding standard indicates that
   "defs.h" should be included first.  Unfortunatly some systems
   (currently Debian GNU/Linux) include the <stdbool.h> via <curses.h>
   and they clash with "bfd.h"'s definiton of true/false.  The correct
   fix is to remove true/false from "bfd.h", however, until that
   happens, hack around it by including "config.h" and <curses.h>
   first.  */
 
#include "config.h"
#ifdef HAVE_NCURSES_H
#include <ncurses.h>
#else
#ifdef HAVE_CURSES_H
#include <curses.h>
#endif
#endif
 
#include "defs.h"
#include "symtab.h"
#include "inferior.h"
#include "command.h"
#include "bfd.h"
#include "symfile.h"
#include "objfiles.h"
#include "target.h"
#include "gdbcore.h"
#include "event-loop.h"
#include "event-top.h"
#include "frame.h"
#include "breakpoint.h"
#include "gdb-events.h"
#include "ui-out.h"
#include "top.h"
#include <readline/readline.h>
#include <unistd.h>
#include <fcntl.h>
 
#include "tui.h"
#include "tuiData.h"
#include "tuiLayout.h"
#include "tuiIO.h"
#include "tuiRegs.h"
#include "tuiWin.h"
#include "tuiStack.h"
#include "tuiDataWin.h"
#include "tuiSourceWin.h"
 
int tui_target_has_run = 0;
 
static void (* tui_target_new_objfile_chain) (struct objfile*);
extern void (*selected_frame_level_changed_hook) (int);
static void tui_event_loop (void);
static void tui_command_loop (void);
 
static void
tui_new_objfile_hook (struct objfile* objfile)
{
  if (tui_active)
    tui_display_main ();
 
  if (tui_target_new_objfile_chain)
    tui_target_new_objfile_chain (objfile);
}
 
static int
tui_query_hook (const char * msg, va_list argp)
{
  int retval;
  int ans2;
  int answer;
 
  /* Automatically answer "yes" if input is not from a terminal.  */
  if (!input_from_terminal_p ())
    return 1;
 
  echo ();
  while (1)
    {
      wrap_here ("");		/* Flush any buffered output */
      gdb_flush (gdb_stdout);
 
      vfprintf_filtered (gdb_stdout, msg, argp);
      printf_filtered ("(y or n) ");
 
      wrap_here ("");
      gdb_flush (gdb_stdout);
 
      answer = tui_getc (stdin);
      clearerr (stdin);		/* in case of C-d */
      if (answer == EOF)	/* C-d */
	{
	  retval = 1;
	  break;
	}
      /* Eat rest of input line, to EOF or newline */
      if (answer != '\n')
	do
	  {
            ans2 = tui_getc (stdin);
	    clearerr (stdin);
	  }
	while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
 
      if (answer >= 'a')
	answer -= 040;
      if (answer == 'Y')
	{
	  retval = 1;
	  break;
	}
      if (answer == 'N')
	{
	  retval = 0;
	  break;
	}
      printf_filtered ("Please answer y or n.\n");
    }
  noecho ();
  return retval;
}
 
/* Prevent recursion of registers_changed_hook().  */
static int tui_refreshing_registers = 0;
 
static void
tui_registers_changed_hook (void)
{
  struct frame_info *fi;
 
  fi = selected_frame;
  if (fi && tui_refreshing_registers == 0)
    {
      tui_refreshing_registers = 1;
#if 0
      tuiCheckDataValues (fi);
#endif
      tui_refreshing_registers = 0;
    }
}
 
static void
tui_register_changed_hook (int regno)
{
  struct frame_info *fi;
 
  fi = selected_frame;
  if (fi && tui_refreshing_registers == 0)
    {
      tui_refreshing_registers = 1;
      tuiCheckDataValues (fi);
      tui_refreshing_registers = 0;
    }
}
 
/* Breakpoint creation hook.
   Update the screen to show the new breakpoint.  */
static void
tui_event_create_breakpoint (int number)
{
  tui_update_all_breakpoint_info ();
}
 
/* Breakpoint deletion hook.
   Refresh the screen to update the breakpoint marks.  */
static void
tui_event_delete_breakpoint (int number)
{
  tui_update_all_breakpoint_info ();
}
 
static void
tui_event_modify_breakpoint (int number)
{
  tui_update_all_breakpoint_info ();
}
 
static void
tui_event_default (int number)
{
  ;
}
 
static struct gdb_events *tui_old_event_hooks;
 
static struct gdb_events tui_event_hooks =
{
  tui_event_create_breakpoint,
  tui_event_delete_breakpoint,
  tui_event_modify_breakpoint,
  tui_event_default,
  tui_event_default,
  tui_event_default
};
 
/* Called when going to wait for the target.
   Leave curses mode and setup program mode.  */
static ptid_t
tui_target_wait_hook (ptid_t pid, struct target_waitstatus *status)
{
  ptid_t res;
 
  /* Leave tui mode (optional).  */
#if 0
  if (tui_active)
    {
      target_terminal_ours ();
      endwin ();
      target_terminal_inferior ();
    }
#endif
  tui_target_has_run = 1;
  res = target_wait (pid, status);
 
  if (tui_active)
    {
      /* TODO: need to refresh (optional).  */
    }
  return res;
}
 
/* The selected frame has changed.  This is happens after a target
   stop or when the user explicitly changes the frame (up/down/thread/...).  */
static void
tui_selected_frame_level_changed_hook (int level)
{
  struct frame_info *fi;
 
  fi = selected_frame;
  /* Ensure that symbols for this frame are read in.  Also, determine the
     source language of this frame, and switch to it if desired.  */
  if (fi)
    {
      struct symtab *s;
 
      s = find_pc_symtab (fi->pc);
      /* elz: this if here fixes the problem with the pc not being displayed
         in the tui asm layout, with no debug symbols. The value of s 
         would be 0 here, and select_source_symtab would abort the
         command by calling the 'error' function */
      if (s)
        select_source_symtab (s);
 
      /* Display the frame position (even if there is no symbols).  */
      tuiShowFrameInfo (fi);
 
      /* Refresh the register window if it's visible.  */
      if (tui_is_window_visible (DATA_WIN))
        {
          tui_refreshing_registers = 1;
          tuiCheckDataValues (fi);
          tui_refreshing_registers = 0;
        }
    }
}
 
/* Called from print_frame_info to list the line we stopped in.  */
static void
tui_print_frame_info_listing_hook (struct symtab *s, int line,
                                   int stopline, int noerror)
{
  select_source_symtab (s);
  tuiShowFrameInfo (selected_frame);
}
 
/* Called when the target process died or is detached.
   Update the status line.  */
static void
tui_detach_hook (void)
{
  tuiShowFrameInfo (0);
  tui_display_main ();
}
 
/* Install the TUI specific hooks.  */
void
tui_install_hooks (void)
{
  target_wait_hook = tui_target_wait_hook;
  selected_frame_level_changed_hook = tui_selected_frame_level_changed_hook;
  print_frame_info_listing_hook = tui_print_frame_info_listing_hook;
 
  query_hook = tui_query_hook;
 
  /* Install the event hooks.  */
  tui_old_event_hooks = set_gdb_event_hooks (&tui_event_hooks);
 
  registers_changed_hook = tui_registers_changed_hook;
  register_changed_hook = tui_register_changed_hook;
  detach_hook = tui_detach_hook;
}
 
/* Remove the TUI specific hooks.  */
void
tui_remove_hooks (void)
{
  target_wait_hook = 0;
  selected_frame_level_changed_hook = 0;
  print_frame_info_listing_hook = 0;
  query_hook = 0;
  registers_changed_hook = 0;
  register_changed_hook = 0;
  detach_hook = 0;
 
  /* Restore the previous event hooks.  */
  set_gdb_event_hooks (tui_old_event_hooks);
}
 
/* Cleanup the tui before exiting.  */
static void
tui_exit (void)
{
  /* Disable the tui.  Curses mode is left leaving the screen
     in a clean state (see endwin()).  */
  tui_disable ();
}
 
/* Initialize all the necessary variables, start the event loop,
   register readline, and stdin, start the loop. */
static void
tui_command_loop (void)
{
  int length;
  char *a_prompt;
  char *gdb_prompt = get_prompt ();
 
  /* If we are using readline, set things up and display the first
     prompt, otherwise just print the prompt. */
  if (async_command_editing_p)
    {
      /* Tell readline what the prompt to display is and what function it
         will need to call after a whole line is read. This also displays
         the first prompt. */
      length = strlen (PREFIX (0)) + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
      a_prompt = (char *) xmalloc (length);
      strcpy (a_prompt, PREFIX (0));
      strcat (a_prompt, gdb_prompt);
      strcat (a_prompt, SUFFIX (0));
      rl_callback_handler_install (a_prompt, input_handler);
    }
  else
    display_gdb_prompt (0);
 
  /* Now it's time to start the event loop. */
  tui_event_loop ();
}
 
/* Start up the event loop. This is the entry point to the event loop
   from the command loop. */
 
static void
tui_event_loop (void)
{
  /* Loop until there is nothing to do. This is the entry point to the
     event loop engine. gdb_do_one_event, called via catch_errors()
     will process one event for each invocation.  It blocks waits for
     an event and then processes it.  >0 when an event is processed, 0
     when catch_errors() caught an error and <0 when there are no
     longer any event sources registered. */
  while (1)
    {
      int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
      if (result < 0)
	break;
 
      /* Update gdb output according to TUI mode.  Since catch_errors
         preserves the uiout from changing, this must be done at top
         level of event loop.  */
      if (tui_active)
        uiout = tui_out;
      else
        uiout = tui_old_uiout;
 
      if (result == 0)
	{
	  /* FIXME: this should really be a call to a hook that is
	     interface specific, because interfaces can display the
	     prompt in their own way. */
	  display_gdb_prompt (0);
	  /* This call looks bizarre, but it is required.  If the user
	     entered a command that caused an error,
	     after_char_processing_hook won't be called from
	     rl_callback_read_char_wrapper.  Using a cleanup there
	     won't work, since we want this function to be called
	     after a new prompt is printed.  */
	  if (after_char_processing_hook)
	    (*after_char_processing_hook) ();
	  /* Maybe better to set a flag to be checked somewhere as to
	     whether display the prompt or not. */
	}
    }
 
  /* We are done with the event loop. There are no more event sources
     to listen to.  So we exit GDB. */
  return;
}
 
/* Initialize the tui by installing several gdb hooks, initializing
   the tui IO and preparing the readline with the kind binding.  */
static void
tui_init_hook (char *argv0)
{
  /* Don't enable the TUI if a specific interpreter is installed.  */
  if (interpreter_p)
    return;
 
  /* Install exit handler to leave the screen in a good shape.  */
  atexit (tui_exit);
 
  initializeStaticData ();
 
  /* Install the permanent hooks.  */
  tui_target_new_objfile_chain = target_new_objfile_hook;
  target_new_objfile_hook = tui_new_objfile_hook;
 
  tui_initialize_io ();
  tui_initialize_readline ();
 
  /* Tell gdb to use the tui_command_loop as the main loop. */
  command_loop_hook = tui_command_loop;
 
  /* Decide in which mode to start using GDB (based on -tui).  */
  if (tui_version)
    {
      tui_enable ();
    }
}
 
/* Initialize the tui.  */
void
_initialize_tui (void)
{
  /* Setup initialization hook.  */
  init_ui_hook = tui_init_hook;
}