Subversion Repositories openrisc_me

/* TUI Interpreter definitions for GDB, the GNU debugger.

   Copyright (C) 2003, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "interps.h"

#include "top.h"

#include "event-top.h"

#include "event-loop.h"

#include "ui-out.h"

#include "cli-out.h"

#include "tui/tui-data.h"

#include "readline/readline.h"

#include "tui/tui-win.h"

#include "tui/tui.h"

#include "tui/tui-io.h"

#include "exceptions.h"

/* Set to 1 when the TUI mode must be activated when we first start

   gdb.  */

static int tui_start_enabled = 0;

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

}

/* These implement the TUI interpreter.  */

static void *

tui_init (void)

{

  /* Install exit handler to leave the screen in a good shape.  */

  atexit (tui_exit);

  tui_initialize_static_data ();

  tui_initialize_io ();

  tui_initialize_win ();

  tui_initialize_readline ();

  return NULL;

}

static int

tui_resume (void *data)

{

  struct ui_file *stream;

  /* gdb_setup_readline will change gdb_stdout.  If the TUI was

     previously writing to gdb_stdout, then set it to the new

     gdb_stdout afterwards.  */

  stream = cli_out_set_stream (tui_old_uiout, gdb_stdout);

  if (stream != gdb_stdout)

    {

      cli_out_set_stream (tui_old_uiout, stream);

      stream = NULL;

    }

  gdb_setup_readline ();

  if (stream != NULL)

    cli_out_set_stream (tui_old_uiout, gdb_stdout);

  if (tui_start_enabled)

    tui_enable ();

  return 1;

}

static int

tui_suspend (void *data)

{

  tui_start_enabled = tui_active;

  tui_disable ();

  return 1;

}

/* Display the prompt if we are silent.  */

static int

tui_display_prompt_p (void *data)

{

  if (interp_quiet_p (NULL))

    return 0;

  else

    return 1;

}

static struct gdb_exception

tui_exec (void *data, const char *command_str)

{

  internal_error (__FILE__, __LINE__, _("tui_exec called"));

}

/* Initialize all the necessary variables, start the event loop,

   register readline, and stdin, start the loop.  */

static void

tui_command_loop (void *data)

{

  /* If we are using readline, set things up and display the first

     prompt, otherwise just print the prompt.  */

  if (async_command_editing_p)

    {

      int length;

      char *a_prompt;

      char *gdb_prompt = get_prompt ();

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

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

}

void

_initialize_tui_interp (void)

{

  static const struct interp_procs procs = {

    tui_init,

    tui_resume,

    tui_suspend,

    tui_exec,

    tui_display_prompt_p,

    tui_command_loop,

  };

  struct interp *tui_interp;

  /* Create a default uiout builder for the TUI.  */

  tui_out = tui_out_new (gdb_stdout);

  interp_add (interp_new (INTERP_TUI, NULL, tui_out, &procs));

  if (interpreter_p && strcmp (interpreter_p, INTERP_TUI) == 0)

    tui_start_enabled = 1;

  if (interpreter_p && strcmp (interpreter_p, INTERP_CONSOLE) == 0)

    {

      xfree (interpreter_p);

      interpreter_p = xstrdup (INTERP_TUI);

    }

}