Subversion Repositories or1k

/* UI_FILE - a generic STDIO like output stream.
   Copyright (C) 1999, 2000 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 "ui-file.h"
#include "tui/tui-file.h"
 
#include <string.h>
 
/* Called instead of fputs for all TUI_FILE output.  */
 
void (*fputs_unfiltered_hook) (const char *linebuffer,
			       struct ui_file * stream);
 
/* A ``struct ui_file'' that is compatible with all the legacy
   code. */
 
/* new */
enum streamtype
{
  afile,
  astring
};
 
/* new */
struct tui_stream
{
  int *ts_magic;
  enum streamtype ts_streamtype;
  FILE *ts_filestream;
  char *ts_strbuf;
  int ts_buflen;
};
 
static ui_file_flush_ftype tui_file_flush;
extern ui_file_fputs_ftype tui_file_fputs;
static ui_file_isatty_ftype tui_file_isatty;
static ui_file_rewind_ftype tui_file_rewind;
static ui_file_put_ftype tui_file_put;
static ui_file_delete_ftype tui_file_delete;
static struct ui_file *tui_file_new PARAMS ((void));
static int tui_file_magic;
 
static struct ui_file *
tui_file_new ()
{
  struct tui_stream *tui = xmalloc (sizeof (struct tui_stream));
  struct ui_file *file = ui_file_new ();
  set_ui_file_data (file, tui, tui_file_delete);
  set_ui_file_flush (file, tui_file_flush);
  set_ui_file_fputs (file, tui_file_fputs);
  set_ui_file_isatty (file, tui_file_isatty);
  set_ui_file_rewind (file, tui_file_rewind);
  set_ui_file_put (file, tui_file_put);
  tui->ts_magic = &tui_file_magic;
  return file;
}
 
static void
tui_file_delete (file)
     struct ui_file *file;
{
  struct tui_stream *tmpstream = ui_file_data (file);
  if (tmpstream->ts_magic != &tui_file_magic)
    internal_error ("tui_file_delete: bad magic number");
  if ((tmpstream->ts_streamtype == astring) &&
      (tmpstream->ts_strbuf != NULL))
    {
      free (tmpstream->ts_strbuf);
    }
  free (tmpstream);
}
 
struct ui_file *
tui_fileopen (stream)
     FILE *stream;
{
  struct ui_file *file = tui_file_new ();
  struct tui_stream *tmpstream = ui_file_data (file);
  tmpstream->ts_streamtype = afile;
  tmpstream->ts_filestream = stream;
  tmpstream->ts_strbuf = NULL;
  tmpstream->ts_buflen = 0;
  return file;
}
 
struct ui_file *
tui_sfileopen (n)
     int n;
{
  struct ui_file *file = tui_file_new ();
  struct tui_stream *tmpstream = ui_file_data (file);
  tmpstream->ts_streamtype = astring;
  tmpstream->ts_filestream = NULL;
  if (n > 0)
    {
      tmpstream->ts_strbuf = xmalloc ((n + 1) * sizeof (char));
      tmpstream->ts_strbuf[0] = '\0';
    }
  else
    /* Do not allocate the buffer now.  The first time something is printed
       one will be allocated by tui_file_adjust_strbuf()  */
    tmpstream->ts_strbuf = NULL;
  tmpstream->ts_buflen = n;
  return file;
}
 
static int
tui_file_isatty (file)
     struct ui_file *file;
{
  struct tui_stream *stream = ui_file_data (file);
  if (stream->ts_magic != &tui_file_magic)
    internal_error ("tui_file_isatty: bad magic number");
  if (stream->ts_streamtype == afile)
    return (isatty (fileno (stream->ts_filestream)));
  else
    return 0;
}
 
static void
tui_file_rewind (file)
     struct ui_file *file;
{
  struct tui_stream *stream = ui_file_data (file);
  if (stream->ts_magic != &tui_file_magic)
    internal_error ("tui_file_rewind: bad magic number");
  stream->ts_strbuf[0] = '\0';
}
 
static void
tui_file_put (struct ui_file *file,
	      ui_file_put_method_ftype *write,
	      void *dest)
{
  struct tui_stream *stream = ui_file_data (file);
  if (stream->ts_magic != &tui_file_magic)
    internal_error ("tui_file_put: bad magic number");
  if (stream->ts_streamtype == astring)
    write (dest, stream->ts_strbuf, strlen (stream->ts_strbuf));
}
 
/* All TUI I/O sent to the *_filtered and *_unfiltered functions
   eventually ends up here.  The fputs_unfiltered_hook is primarily
   used by GUIs to collect all output and send it to the GUI, instead
   of the controlling terminal.  Only output to gdb_stdout and
   gdb_stderr are sent to the hook.  Everything else is sent on to
   fputs to allow file I/O to be handled appropriately.  */
 
/* FIXME: Should be broken up and moved to a TUI specific file. */
 
void
tui_file_fputs (linebuffer, file)
     const char *linebuffer;
     struct ui_file *file;
{
  struct tui_stream *stream = ui_file_data (file);
#if defined(TUI)
  extern int tui_owns_terminal;
#endif
  /* NOTE: cagney/1999-10-13: The use of fputs_unfiltered_hook is
     seriously discouraged.  Those wanting to hook output should
     instead implement their own ui_file object and install that. See
     also tui_file_flush(). */
  if (fputs_unfiltered_hook
      && (file == gdb_stdout
	  || file == gdb_stderr))
    fputs_unfiltered_hook (linebuffer, file);
  else
    {
#if defined(TUI)
      if (tui_version && tui_owns_terminal)
	{
	  /* If we get here somehow while updating the TUI (from
	   * within a tuiDo(), then we need to temporarily 
	   * set up the terminal for GDB output. This probably just
	   * happens on error output.
	   */
 
	  if (stream->ts_streamtype == astring)
	    {
	      tui_file_adjust_strbuf (strlen (linebuffer), stream);
	      strcat (stream->ts_strbuf, linebuffer);
	    }
	  else
	    {
	      tuiTermUnsetup (0, (tui_version) ? cmdWin->detail.commandInfo.curch : 0);
	      fputs (linebuffer, stream->ts_filestream);
	      tuiTermSetup (0);
	      if (linebuffer[strlen (linebuffer) - 1] == '\n')
		tuiClearCommandCharCount ();
	      else
		tuiIncrCommandCharCountBy (strlen (linebuffer));
	    }
	}
      else
	{
	  /* The normal case - just do a fputs() */
	  if (stream->ts_streamtype == astring)
	    {
	      tui_file_adjust_strbuf (strlen (linebuffer), stream);
	      strcat (stream->ts_strbuf, linebuffer);
	    }
	  else
	    fputs (linebuffer, stream->ts_filestream);
	}
 
 
#else
      if (stream->ts_streamtype == astring)
	{
	  tui_file_adjust_strbuf (strlen (linebuffer), file);
	  strcat (stream->ts_strbuf, linebuffer);
	}
      else
	fputs (linebuffer, stream->ts_filestream);
#endif
    }
}
 
char *
tui_file_get_strbuf (struct ui_file *file)
{
  struct tui_stream *stream = ui_file_data (file);
  if (stream->ts_magic != &tui_file_magic)
    internal_error ("tui_file_get_strbuf: bad magic number");
  return (stream->ts_strbuf);
}
 
/* adjust the length of the buffer by the amount necessary
   to accomodate appending a string of length N to the buffer contents */
void
tui_file_adjust_strbuf (int n, struct ui_file *file)
{
  struct tui_stream *stream = ui_file_data (file);
  int non_null_chars;
  if (stream->ts_magic != &tui_file_magic)
    internal_error ("tui_file_adjust_strbuf: bad magic number");
 
  if (stream->ts_streamtype != astring)
    return;
 
  if (stream->ts_strbuf)
    {
      /* There is already a buffer allocated */
      non_null_chars = strlen (stream->ts_strbuf);
 
      if (n > (stream->ts_buflen - non_null_chars - 1))
	{
	  stream->ts_buflen = n + non_null_chars + 1;
	  stream->ts_strbuf = xrealloc (stream->ts_strbuf, stream->ts_buflen);
	}
    }
  else
    /* No buffer yet, so allocate one of the desired size */
    stream->ts_strbuf = xmalloc ((n + 1) * sizeof (char));
}
 
static void
tui_file_flush (file)
     struct ui_file *file;
{
  struct tui_stream *stream = ui_file_data (file);
  if (stream->ts_magic != &tui_file_magic)
    internal_error ("tui_file_flush: bad magic number");
 
  /* NOTE: cagney/1999-10-12: If we've been linked with code that uses
     fputs_unfiltered_hook then we assume that it doesn't need to know
     about flushes.  Code that does need to know about flushes can
     implement a proper ui_file object. */
  if (fputs_unfiltered_hook)
    return;
 
  switch (stream->ts_streamtype)
    {
    case astring:
      break;
    case afile:
      fflush (stream->ts_filestream);
      break;
    }
}