OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [ui-out.c] - Diff between revs 827 and 840

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 827 Rev 840
/* Output generating routines for GDB.
/* Output generating routines for GDB.
 
 
   Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008
   Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
 
 
   Contributed by Cygnus Solutions.
   Contributed by Cygnus Solutions.
   Written by Fernando Nasser for Cygnus.
   Written by Fernando Nasser for Cygnus.
 
 
   This file is part of GDB.
   This file is part of GDB.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
#include "defs.h"
#include "defs.h"
#include "gdb_string.h"
#include "gdb_string.h"
#include "expression.h"         /* For language.h */
#include "expression.h"         /* For language.h */
#include "language.h"
#include "language.h"
#include "ui-out.h"
#include "ui-out.h"
#include "gdb_assert.h"
#include "gdb_assert.h"
 
 
/* table header structures */
/* table header structures */
 
 
struct ui_out_hdr
struct ui_out_hdr
  {
  {
    int colno;
    int colno;
    int width;
    int width;
    int alignment;
    int alignment;
    char *col_name;
    char *col_name;
    char *colhdr;
    char *colhdr;
    struct ui_out_hdr *next;
    struct ui_out_hdr *next;
  };
  };
 
 
/* Maintain a stack so that the info applicable to the inner most list
/* Maintain a stack so that the info applicable to the inner most list
   is always available.  Stack/nested level 0 is reserved for the
   is always available.  Stack/nested level 0 is reserved for the
   top-level result. */
   top-level result. */
 
 
enum { MAX_UI_OUT_LEVELS = 6 };
enum { MAX_UI_OUT_LEVELS = 6 };
 
 
struct ui_out_level
struct ui_out_level
  {
  {
    /* Count each field; the first element is for non-list fields */
    /* Count each field; the first element is for non-list fields */
    int field_count;
    int field_count;
    /* The type of this level. */
    /* The type of this level. */
    enum ui_out_type type;
    enum ui_out_type type;
  };
  };
 
 
/* Tables are special.  Maintain a separate structure that tracks
/* Tables are special.  Maintain a separate structure that tracks
   their state.  At present an output can only contain a single table
   their state.  At present an output can only contain a single table
   but that restriction might eventually be lifted.  */
   but that restriction might eventually be lifted.  */
 
 
struct ui_out_table
struct ui_out_table
{
{
  /* If on, a table is being generated.  */
  /* If on, a table is being generated.  */
  int flag;
  int flag;
 
 
  /* If on, the body of a table is being generated.  If off, the table
  /* If on, the body of a table is being generated.  If off, the table
     header is being generated.  */
     header is being generated.  */
  int body_flag;
  int body_flag;
 
 
  /* The level at which each entry of the table is to be found.  A row
  /* The level at which each entry of the table is to be found.  A row
     (a tuple) is made up of entries.  Consequently ENTRY_LEVEL is one
     (a tuple) is made up of entries.  Consequently ENTRY_LEVEL is one
     above that of the table.  */
     above that of the table.  */
  int entry_level;
  int entry_level;
 
 
  /* Number of table columns (as specified in the table_begin call).  */
  /* Number of table columns (as specified in the table_begin call).  */
  int columns;
  int columns;
 
 
  /* String identifying the table (as specified in the table_begin
  /* String identifying the table (as specified in the table_begin
     call).  */
     call).  */
  char *id;
  char *id;
 
 
  /* Points to the first table header (if any).  */
  /* Points to the first table header (if any).  */
  struct ui_out_hdr *header_first;
  struct ui_out_hdr *header_first;
 
 
  /* Points to the last table header (if any).  */
  /* Points to the last table header (if any).  */
  struct ui_out_hdr *header_last;
  struct ui_out_hdr *header_last;
 
 
  /* Points to header of NEXT column to format.  */
  /* Points to header of NEXT column to format.  */
  struct ui_out_hdr *header_next;
  struct ui_out_hdr *header_next;
 
 
};
};
 
 
 
 
/* The ui_out structure */
/* The ui_out structure */
/* Any change here requires a corresponding one in the initialization
/* Any change here requires a corresponding one in the initialization
   of the default uiout, which is statically initialized */
   of the default uiout, which is statically initialized */
 
 
struct ui_out
struct ui_out
  {
  {
    int flags;
    int flags;
    /* specific implementation of ui-out */
    /* specific implementation of ui-out */
    struct ui_out_impl *impl;
    struct ui_out_impl *impl;
    struct ui_out_data *data;
    struct ui_out_data *data;
 
 
    /* Sub structure tracking the ui-out depth.  */
    /* Sub structure tracking the ui-out depth.  */
    int level;
    int level;
    struct ui_out_level levels[MAX_UI_OUT_LEVELS];
    struct ui_out_level levels[MAX_UI_OUT_LEVELS];
 
 
    /* A table, if any.  At present only a single table is supported.  */
    /* A table, if any.  At present only a single table is supported.  */
    struct ui_out_table table;
    struct ui_out_table table;
  };
  };
 
 
/* The current (inner most) level. */
/* The current (inner most) level. */
static struct ui_out_level *
static struct ui_out_level *
current_level (struct ui_out *uiout)
current_level (struct ui_out *uiout)
{
{
  return &uiout->levels[uiout->level];
  return &uiout->levels[uiout->level];
}
}
 
 
/* Create a new level, of TYPE.  Return the new level's index. */
/* Create a new level, of TYPE.  Return the new level's index. */
static int
static int
push_level (struct ui_out *uiout,
push_level (struct ui_out *uiout,
            enum ui_out_type type,
            enum ui_out_type type,
            const char *id)
            const char *id)
{
{
  struct ui_out_level *current;
  struct ui_out_level *current;
  /* We had better not overflow the buffer. */
  /* We had better not overflow the buffer. */
  uiout->level++;
  uiout->level++;
  gdb_assert (uiout->level >= 0 && uiout->level < MAX_UI_OUT_LEVELS);
  gdb_assert (uiout->level >= 0 && uiout->level < MAX_UI_OUT_LEVELS);
  current = current_level (uiout);
  current = current_level (uiout);
  current->field_count = 0;
  current->field_count = 0;
  current->type = type;
  current->type = type;
  return uiout->level;
  return uiout->level;
}
}
 
 
/* Discard the current level, return the discarded level's index.
/* Discard the current level, return the discarded level's index.
   TYPE is the type of the level being discarded. */
   TYPE is the type of the level being discarded. */
static int
static int
pop_level (struct ui_out *uiout,
pop_level (struct ui_out *uiout,
           enum ui_out_type type)
           enum ui_out_type type)
{
{
  /* We had better not underflow the buffer. */
  /* We had better not underflow the buffer. */
  gdb_assert (uiout->level > 0 && uiout->level < MAX_UI_OUT_LEVELS);
  gdb_assert (uiout->level > 0 && uiout->level < MAX_UI_OUT_LEVELS);
  gdb_assert (current_level (uiout)->type == type);
  gdb_assert (current_level (uiout)->type == type);
  uiout->level--;
  uiout->level--;
  return uiout->level + 1;
  return uiout->level + 1;
}
}
 
 
 
 
/* These are the default implementation functions */
/* These are the default implementation functions */
 
 
static void default_table_begin (struct ui_out *uiout, int nbrofcols,
static void default_table_begin (struct ui_out *uiout, int nbrofcols,
                                 int nr_rows, const char *tblid);
                                 int nr_rows, const char *tblid);
static void default_table_body (struct ui_out *uiout);
static void default_table_body (struct ui_out *uiout);
static void default_table_end (struct ui_out *uiout);
static void default_table_end (struct ui_out *uiout);
static void default_table_header (struct ui_out *uiout, int width,
static void default_table_header (struct ui_out *uiout, int width,
                                  enum ui_align alig, const char *col_name,
                                  enum ui_align alig, const char *col_name,
                                  const char *colhdr);
                                  const char *colhdr);
static void default_begin (struct ui_out *uiout,
static void default_begin (struct ui_out *uiout,
                           enum ui_out_type type,
                           enum ui_out_type type,
                           int level, const char *id);
                           int level, const char *id);
static void default_end (struct ui_out *uiout,
static void default_end (struct ui_out *uiout,
                         enum ui_out_type type,
                         enum ui_out_type type,
                         int level);
                         int level);
static void default_field_int (struct ui_out *uiout, int fldno, int width,
static void default_field_int (struct ui_out *uiout, int fldno, int width,
                               enum ui_align alig,
                               enum ui_align alig,
                               const char *fldname,
                               const char *fldname,
                               int value);
                               int value);
static void default_field_skip (struct ui_out *uiout, int fldno, int width,
static void default_field_skip (struct ui_out *uiout, int fldno, int width,
                                enum ui_align alig,
                                enum ui_align alig,
                                const char *fldname);
                                const char *fldname);
static void default_field_string (struct ui_out *uiout, int fldno, int width,
static void default_field_string (struct ui_out *uiout, int fldno, int width,
                                  enum ui_align align,
                                  enum ui_align align,
                                  const char *fldname,
                                  const char *fldname,
                                  const char *string);
                                  const char *string);
static void default_field_fmt (struct ui_out *uiout, int fldno,
static void default_field_fmt (struct ui_out *uiout, int fldno,
                               int width, enum ui_align align,
                               int width, enum ui_align align,
                               const char *fldname,
                               const char *fldname,
                               const char *format,
                               const char *format,
                               va_list args) ATTR_FORMAT (printf, 6, 0);
                               va_list args) ATTR_FORMAT (printf, 6, 0);
static void default_spaces (struct ui_out *uiout, int numspaces);
static void default_spaces (struct ui_out *uiout, int numspaces);
static void default_text (struct ui_out *uiout, const char *string);
static void default_text (struct ui_out *uiout, const char *string);
static void default_message (struct ui_out *uiout, int verbosity,
static void default_message (struct ui_out *uiout, int verbosity,
                             const char *format,
                             const char *format,
                             va_list args) ATTR_FORMAT (printf, 3, 0);
                             va_list args) ATTR_FORMAT (printf, 3, 0);
static void default_wrap_hint (struct ui_out *uiout, char *identstring);
static void default_wrap_hint (struct ui_out *uiout, char *identstring);
static void default_flush (struct ui_out *uiout);
static void default_flush (struct ui_out *uiout);
 
 
/* This is the default ui-out implementation functions vector */
/* This is the default ui-out implementation functions vector */
 
 
struct ui_out_impl default_ui_out_impl =
struct ui_out_impl default_ui_out_impl =
{
{
  default_table_begin,
  default_table_begin,
  default_table_body,
  default_table_body,
  default_table_end,
  default_table_end,
  default_table_header,
  default_table_header,
  default_begin,
  default_begin,
  default_end,
  default_end,
  default_field_int,
  default_field_int,
  default_field_skip,
  default_field_skip,
  default_field_string,
  default_field_string,
  default_field_fmt,
  default_field_fmt,
  default_spaces,
  default_spaces,
  default_text,
  default_text,
  default_message,
  default_message,
  default_wrap_hint,
  default_wrap_hint,
  default_flush,
  default_flush,
  NULL,
  NULL,
  0, /* Does not need MI hacks.  */
  0, /* Does not need MI hacks.  */
};
};
 
 
/* The default ui_out */
/* The default ui_out */
 
 
struct ui_out def_uiout =
struct ui_out def_uiout =
{
{
  0,                             /* flags */
  0,                             /* flags */
  &default_ui_out_impl,         /* impl */
  &default_ui_out_impl,         /* impl */
};
};
 
 
/* Pointer to current ui_out */
/* Pointer to current ui_out */
/* FIXME: This should not be a global, but something passed down from main.c
/* FIXME: This should not be a global, but something passed down from main.c
   or top.c */
   or top.c */
 
 
struct ui_out *uiout = &def_uiout;
struct ui_out *uiout = &def_uiout;
 
 
/* These are the interfaces to implementation functions */
/* These are the interfaces to implementation functions */
 
 
static void uo_table_begin (struct ui_out *uiout, int nbrofcols,
static void uo_table_begin (struct ui_out *uiout, int nbrofcols,
                            int nr_rows, const char *tblid);
                            int nr_rows, const char *tblid);
static void uo_table_body (struct ui_out *uiout);
static void uo_table_body (struct ui_out *uiout);
static void uo_table_end (struct ui_out *uiout);
static void uo_table_end (struct ui_out *uiout);
static void uo_table_header (struct ui_out *uiout, int width,
static void uo_table_header (struct ui_out *uiout, int width,
                             enum ui_align align, const char *col_name,
                             enum ui_align align, const char *col_name,
                             const char *colhdr);
                             const char *colhdr);
static void uo_begin (struct ui_out *uiout,
static void uo_begin (struct ui_out *uiout,
                      enum ui_out_type type,
                      enum ui_out_type type,
                      int level, const char *id);
                      int level, const char *id);
static void uo_end (struct ui_out *uiout,
static void uo_end (struct ui_out *uiout,
                    enum ui_out_type type,
                    enum ui_out_type type,
                    int level);
                    int level);
static void uo_field_int (struct ui_out *uiout, int fldno, int width,
static void uo_field_int (struct ui_out *uiout, int fldno, int width,
                          enum ui_align align, const char *fldname, int value);
                          enum ui_align align, const char *fldname, int value);
static void uo_field_skip (struct ui_out *uiout, int fldno, int width,
static void uo_field_skip (struct ui_out *uiout, int fldno, int width,
                           enum ui_align align, const char *fldname);
                           enum ui_align align, const char *fldname);
static void uo_field_string (struct ui_out *uiout, int fldno, int width,
static void uo_field_string (struct ui_out *uiout, int fldno, int width,
                             enum ui_align align, const char *fldname,
                             enum ui_align align, const char *fldname,
                             const char *string);
                             const char *string);
static void uo_field_fmt (struct ui_out *uiout, int fldno, int width,
static void uo_field_fmt (struct ui_out *uiout, int fldno, int width,
                          enum ui_align align, const char *fldname,
                          enum ui_align align, const char *fldname,
                          const char *format, va_list args)
                          const char *format, va_list args)
     ATTR_FORMAT (printf, 6, 0);
     ATTR_FORMAT (printf, 6, 0);
static void uo_spaces (struct ui_out *uiout, int numspaces);
static void uo_spaces (struct ui_out *uiout, int numspaces);
static void uo_text (struct ui_out *uiout, const char *string);
static void uo_text (struct ui_out *uiout, const char *string);
static void uo_message (struct ui_out *uiout, int verbosity,
static void uo_message (struct ui_out *uiout, int verbosity,
                        const char *format, va_list args)
                        const char *format, va_list args)
     ATTR_FORMAT (printf, 3, 0);
     ATTR_FORMAT (printf, 3, 0);
static void uo_wrap_hint (struct ui_out *uiout, char *identstring);
static void uo_wrap_hint (struct ui_out *uiout, char *identstring);
static void uo_flush (struct ui_out *uiout);
static void uo_flush (struct ui_out *uiout);
static int uo_redirect (struct ui_out *uiout, struct ui_file *outstream);
static int uo_redirect (struct ui_out *uiout, struct ui_file *outstream);
 
 
/* Prototypes for local functions */
/* Prototypes for local functions */
 
 
extern void _initialize_ui_out (void);
extern void _initialize_ui_out (void);
static void append_header_to_list (struct ui_out *uiout, int width,
static void append_header_to_list (struct ui_out *uiout, int width,
                                   int alignment, const char *col_name,
                                   int alignment, const char *col_name,
                                   const char *colhdr);
                                   const char *colhdr);
static int get_next_header (struct ui_out *uiout, int *colno, int *width,
static int get_next_header (struct ui_out *uiout, int *colno, int *width,
                            int *alignment, char **colhdr);
                            int *alignment, char **colhdr);
static void clear_header_list (struct ui_out *uiout);
static void clear_header_list (struct ui_out *uiout);
static void verify_field (struct ui_out *uiout, int *fldno, int *width,
static void verify_field (struct ui_out *uiout, int *fldno, int *width,
                          int *align);
                          int *align);
 
 
/* exported functions (ui_out API) */
/* exported functions (ui_out API) */
 
 
/* Mark beginning of a table */
/* Mark beginning of a table */
 
 
static void
static void
ui_out_table_begin (struct ui_out *uiout, int nbrofcols,
ui_out_table_begin (struct ui_out *uiout, int nbrofcols,
                    int nr_rows,
                    int nr_rows,
                    const char *tblid)
                    const char *tblid)
{
{
  if (uiout->table.flag)
  if (uiout->table.flag)
    internal_error (__FILE__, __LINE__,
    internal_error (__FILE__, __LINE__,
                    _("tables cannot be nested; table_begin found before \
                    _("tables cannot be nested; table_begin found before \
previous table_end."));
previous table_end."));
 
 
  uiout->table.flag = 1;
  uiout->table.flag = 1;
  uiout->table.body_flag = 0;
  uiout->table.body_flag = 0;
  uiout->table.entry_level = uiout->level + 1;
  uiout->table.entry_level = uiout->level + 1;
  uiout->table.columns = nbrofcols;
  uiout->table.columns = nbrofcols;
  if (tblid != NULL)
  if (tblid != NULL)
    uiout->table.id = xstrdup (tblid);
    uiout->table.id = xstrdup (tblid);
  else
  else
    uiout->table.id = NULL;
    uiout->table.id = NULL;
  clear_header_list (uiout);
  clear_header_list (uiout);
 
 
  uo_table_begin (uiout, nbrofcols, nr_rows, uiout->table.id);
  uo_table_begin (uiout, nbrofcols, nr_rows, uiout->table.id);
}
}
 
 
void
void
ui_out_table_body (struct ui_out *uiout)
ui_out_table_body (struct ui_out *uiout)
{
{
  if (!uiout->table.flag)
  if (!uiout->table.flag)
    internal_error (__FILE__, __LINE__,
    internal_error (__FILE__, __LINE__,
                    _("table_body outside a table is not valid; it must be \
                    _("table_body outside a table is not valid; it must be \
after a table_begin and before a table_end."));
after a table_begin and before a table_end."));
  if (uiout->table.body_flag)
  if (uiout->table.body_flag)
    internal_error (__FILE__, __LINE__,
    internal_error (__FILE__, __LINE__,
                    _("extra table_body call not allowed; there must be \
                    _("extra table_body call not allowed; there must be \
only one table_body after a table_begin and before a table_end."));
only one table_body after a table_begin and before a table_end."));
  if (uiout->table.header_next->colno != uiout->table.columns)
  if (uiout->table.header_next->colno != uiout->table.columns)
    internal_error (__FILE__, __LINE__,
    internal_error (__FILE__, __LINE__,
                    _("number of headers differ from number of table \
                    _("number of headers differ from number of table \
columns."));
columns."));
 
 
  uiout->table.body_flag = 1;
  uiout->table.body_flag = 1;
  uiout->table.header_next = uiout->table.header_first;
  uiout->table.header_next = uiout->table.header_first;
 
 
  uo_table_body (uiout);
  uo_table_body (uiout);
}
}
 
 
static void
static void
ui_out_table_end (struct ui_out *uiout)
ui_out_table_end (struct ui_out *uiout)
{
{
  if (!uiout->table.flag)
  if (!uiout->table.flag)
    internal_error (__FILE__, __LINE__,
    internal_error (__FILE__, __LINE__,
                    _("misplaced table_end or missing table_begin."));
                    _("misplaced table_end or missing table_begin."));
 
 
  uiout->table.entry_level = 0;
  uiout->table.entry_level = 0;
  uiout->table.body_flag = 0;
  uiout->table.body_flag = 0;
  uiout->table.flag = 0;
  uiout->table.flag = 0;
 
 
  uo_table_end (uiout);
  uo_table_end (uiout);
 
 
  if (uiout->table.id)
  if (uiout->table.id)
    xfree (uiout->table.id);
    xfree (uiout->table.id);
  clear_header_list (uiout);
  clear_header_list (uiout);
}
}
 
 
void
void
ui_out_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
ui_out_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
                     const char *col_name,
                     const char *col_name,
                     const char *colhdr)
                     const char *colhdr)
{
{
  if (!uiout->table.flag || uiout->table.body_flag)
  if (!uiout->table.flag || uiout->table.body_flag)
    internal_error (__FILE__, __LINE__,
    internal_error (__FILE__, __LINE__,
                    _("table header must be specified after table_begin \
                    _("table header must be specified after table_begin \
and before table_body."));
and before table_body."));
 
 
  append_header_to_list (uiout, width, alignment, col_name, colhdr);
  append_header_to_list (uiout, width, alignment, col_name, colhdr);
 
 
  uo_table_header (uiout, width, alignment, col_name, colhdr);
  uo_table_header (uiout, width, alignment, col_name, colhdr);
}
}
 
 
static void
static void
do_cleanup_table_end (void *data)
do_cleanup_table_end (void *data)
{
{
  struct ui_out *ui_out = data;
  struct ui_out *ui_out = data;
 
 
  ui_out_table_end (ui_out);
  ui_out_table_end (ui_out);
}
}
 
 
struct cleanup *
struct cleanup *
make_cleanup_ui_out_table_begin_end (struct ui_out *ui_out, int nr_cols,
make_cleanup_ui_out_table_begin_end (struct ui_out *ui_out, int nr_cols,
                                     int nr_rows, const char *tblid)
                                     int nr_rows, const char *tblid)
{
{
  ui_out_table_begin (ui_out, nr_cols, nr_rows, tblid);
  ui_out_table_begin (ui_out, nr_cols, nr_rows, tblid);
  return make_cleanup (do_cleanup_table_end, ui_out);
  return make_cleanup (do_cleanup_table_end, ui_out);
}
}
 
 
void
void
ui_out_begin (struct ui_out *uiout,
ui_out_begin (struct ui_out *uiout,
              enum ui_out_type type,
              enum ui_out_type type,
              const char *id)
              const char *id)
{
{
  int new_level;
  int new_level;
  if (uiout->table.flag && !uiout->table.body_flag)
  if (uiout->table.flag && !uiout->table.body_flag)
    internal_error (__FILE__, __LINE__,
    internal_error (__FILE__, __LINE__,
                    _("table header or table_body expected; lists must be \
                    _("table header or table_body expected; lists must be \
specified after table_body."));
specified after table_body."));
 
 
  /* Be careful to verify the ``field'' before the new tuple/list is
  /* Be careful to verify the ``field'' before the new tuple/list is
     pushed onto the stack.  That way the containing list/table/row is
     pushed onto the stack.  That way the containing list/table/row is
     verified and not the newly created tuple/list.  This verification
     verified and not the newly created tuple/list.  This verification
     is needed (at least) for the case where a table row entry
     is needed (at least) for the case where a table row entry
     contains either a tuple/list.  For that case bookkeeping such as
     contains either a tuple/list.  For that case bookkeeping such as
     updating the column count or advancing to the next heading still
     updating the column count or advancing to the next heading still
     needs to be performed.  */
     needs to be performed.  */
  {
  {
    int fldno;
    int fldno;
    int width;
    int width;
    int align;
    int align;
    verify_field (uiout, &fldno, &width, &align);
    verify_field (uiout, &fldno, &width, &align);
  }
  }
 
 
  new_level = push_level (uiout, type, id);
  new_level = push_level (uiout, type, id);
 
 
  /* If the push puts us at the same level as a table row entry, we've
  /* If the push puts us at the same level as a table row entry, we've
     got a new table row.  Put the header pointer back to the start.  */
     got a new table row.  Put the header pointer back to the start.  */
  if (uiout->table.body_flag
  if (uiout->table.body_flag
      && uiout->table.entry_level == new_level)
      && uiout->table.entry_level == new_level)
    uiout->table.header_next = uiout->table.header_first;
    uiout->table.header_next = uiout->table.header_first;
 
 
  uo_begin (uiout, type, new_level, id);
  uo_begin (uiout, type, new_level, id);
}
}
 
 
void
void
ui_out_end (struct ui_out *uiout,
ui_out_end (struct ui_out *uiout,
            enum ui_out_type type)
            enum ui_out_type type)
{
{
  int old_level = pop_level (uiout, type);
  int old_level = pop_level (uiout, type);
  uo_end (uiout, type, old_level);
  uo_end (uiout, type, old_level);
}
}
 
 
struct ui_out_end_cleanup_data
struct ui_out_end_cleanup_data
{
{
  struct ui_out *uiout;
  struct ui_out *uiout;
  enum ui_out_type type;
  enum ui_out_type type;
};
};
 
 
static void
static void
do_cleanup_end (void *data)
do_cleanup_end (void *data)
{
{
  struct ui_out_end_cleanup_data *end_cleanup_data = data;
  struct ui_out_end_cleanup_data *end_cleanup_data = data;
  ui_out_end (end_cleanup_data->uiout, end_cleanup_data->type);
  ui_out_end (end_cleanup_data->uiout, end_cleanup_data->type);
  xfree (end_cleanup_data);
  xfree (end_cleanup_data);
}
}
 
 
static struct cleanup *
static struct cleanup *
make_cleanup_ui_out_end (struct ui_out *uiout,
make_cleanup_ui_out_end (struct ui_out *uiout,
                         enum ui_out_type type)
                         enum ui_out_type type)
{
{
  struct ui_out_end_cleanup_data *end_cleanup_data;
  struct ui_out_end_cleanup_data *end_cleanup_data;
  end_cleanup_data = XMALLOC (struct ui_out_end_cleanup_data);
  end_cleanup_data = XMALLOC (struct ui_out_end_cleanup_data);
  end_cleanup_data->uiout = uiout;
  end_cleanup_data->uiout = uiout;
  end_cleanup_data->type = type;
  end_cleanup_data->type = type;
  return make_cleanup (do_cleanup_end, end_cleanup_data);
  return make_cleanup (do_cleanup_end, end_cleanup_data);
}
}
 
 
struct cleanup *
struct cleanup *
make_cleanup_ui_out_tuple_begin_end (struct ui_out *uiout,
make_cleanup_ui_out_tuple_begin_end (struct ui_out *uiout,
                                     const char *id)
                                     const char *id)
{
{
  ui_out_begin (uiout, ui_out_type_tuple, id);
  ui_out_begin (uiout, ui_out_type_tuple, id);
  return make_cleanup_ui_out_end (uiout, ui_out_type_tuple);
  return make_cleanup_ui_out_end (uiout, ui_out_type_tuple);
}
}
 
 
struct cleanup *
struct cleanup *
make_cleanup_ui_out_list_begin_end (struct ui_out *uiout,
make_cleanup_ui_out_list_begin_end (struct ui_out *uiout,
                                    const char *id)
                                    const char *id)
{
{
  ui_out_begin (uiout, ui_out_type_list, id);
  ui_out_begin (uiout, ui_out_type_list, id);
  return make_cleanup_ui_out_end (uiout, ui_out_type_list);
  return make_cleanup_ui_out_end (uiout, ui_out_type_list);
}
}
 
 
void
void
ui_out_field_int (struct ui_out *uiout,
ui_out_field_int (struct ui_out *uiout,
                  const char *fldname,
                  const char *fldname,
                  int value)
                  int value)
{
{
  int fldno;
  int fldno;
  int width;
  int width;
  int align;
  int align;
  struct ui_out_level *current = current_level (uiout);
  struct ui_out_level *current = current_level (uiout);
 
 
  verify_field (uiout, &fldno, &width, &align);
  verify_field (uiout, &fldno, &width, &align);
 
 
  uo_field_int (uiout, fldno, width, align, fldname, value);
  uo_field_int (uiout, fldno, width, align, fldname, value);
}
}
 
 
void
void
ui_out_field_fmt_int (struct ui_out *uiout,
ui_out_field_fmt_int (struct ui_out *uiout,
                      int input_width,
                      int input_width,
                      enum ui_align input_align,
                      enum ui_align input_align,
                      const char *fldname,
                      const char *fldname,
                      int value)
                      int value)
{
{
  int fldno;
  int fldno;
  int width;
  int width;
  int align;
  int align;
  struct ui_out_level *current = current_level (uiout);
  struct ui_out_level *current = current_level (uiout);
 
 
  verify_field (uiout, &fldno, &width, &align);
  verify_field (uiout, &fldno, &width, &align);
 
 
  uo_field_int (uiout, fldno, input_width, input_align, fldname, value);
  uo_field_int (uiout, fldno, input_width, input_align, fldname, value);
}
}
 
 
void
void
ui_out_field_core_addr (struct ui_out *uiout,
ui_out_field_core_addr (struct ui_out *uiout,
                        const char *fldname,
                        const char *fldname,
                        CORE_ADDR address)
                        CORE_ADDR address)
{
{
  char addstr[20];
  char addstr[20];
  int addr_bit = gdbarch_addr_bit (current_gdbarch);
  int addr_bit = gdbarch_addr_bit (current_gdbarch);
 
 
  if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
  if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
    address &= ((CORE_ADDR) 1 << addr_bit) - 1;
    address &= ((CORE_ADDR) 1 << addr_bit) - 1;
 
 
  /* FIXME: cagney/2002-05-03: Need local_address_string() function
  /* FIXME: cagney/2002-05-03: Need local_address_string() function
     that returns the language localized string formatted to a width
     that returns the language localized string formatted to a width
     based on gdbarch_addr_bit.  */
     based on gdbarch_addr_bit.  */
  if (addr_bit <= 32)
  if (addr_bit <= 32)
    strcpy (addstr, hex_string_custom (address, 8));
    strcpy (addstr, hex_string_custom (address, 8));
  else
  else
    strcpy (addstr, hex_string_custom (address, 16));
    strcpy (addstr, hex_string_custom (address, 16));
 
 
  ui_out_field_string (uiout, fldname, addstr);
  ui_out_field_string (uiout, fldname, addstr);
}
}
 
 
void
void
ui_out_field_stream (struct ui_out *uiout,
ui_out_field_stream (struct ui_out *uiout,
                     const char *fldname,
                     const char *fldname,
                     struct ui_stream *buf)
                     struct ui_stream *buf)
{
{
  long length;
  long length;
  char *buffer = ui_file_xstrdup (buf->stream, &length);
  char *buffer = ui_file_xstrdup (buf->stream, &length);
  struct cleanup *old_cleanup = make_cleanup (xfree, buffer);
  struct cleanup *old_cleanup = make_cleanup (xfree, buffer);
  if (length > 0)
  if (length > 0)
    ui_out_field_string (uiout, fldname, buffer);
    ui_out_field_string (uiout, fldname, buffer);
  else
  else
    ui_out_field_skip (uiout, fldname);
    ui_out_field_skip (uiout, fldname);
  ui_file_rewind (buf->stream);
  ui_file_rewind (buf->stream);
  do_cleanups (old_cleanup);
  do_cleanups (old_cleanup);
}
}
 
 
/* used to ommit a field */
/* used to ommit a field */
 
 
void
void
ui_out_field_skip (struct ui_out *uiout,
ui_out_field_skip (struct ui_out *uiout,
                   const char *fldname)
                   const char *fldname)
{
{
  int fldno;
  int fldno;
  int width;
  int width;
  int align;
  int align;
 
 
  verify_field (uiout, &fldno, &width, &align);
  verify_field (uiout, &fldno, &width, &align);
 
 
  uo_field_skip (uiout, fldno, width, align, fldname);
  uo_field_skip (uiout, fldno, width, align, fldname);
}
}
 
 
void
void
ui_out_field_string (struct ui_out *uiout,
ui_out_field_string (struct ui_out *uiout,
                     const char *fldname,
                     const char *fldname,
                     const char *string)
                     const char *string)
{
{
  int fldno;
  int fldno;
  int width;
  int width;
  int align;
  int align;
 
 
  verify_field (uiout, &fldno, &width, &align);
  verify_field (uiout, &fldno, &width, &align);
 
 
  uo_field_string (uiout, fldno, width, align, fldname, string);
  uo_field_string (uiout, fldno, width, align, fldname, string);
}
}
 
 
/* VARARGS */
/* VARARGS */
void
void
ui_out_field_fmt (struct ui_out *uiout,
ui_out_field_fmt (struct ui_out *uiout,
                  const char *fldname,
                  const char *fldname,
                  const char *format, ...)
                  const char *format, ...)
{
{
  va_list args;
  va_list args;
  int fldno;
  int fldno;
  int width;
  int width;
  int align;
  int align;
 
 
  /* will not align, but has to call anyway */
  /* will not align, but has to call anyway */
  verify_field (uiout, &fldno, &width, &align);
  verify_field (uiout, &fldno, &width, &align);
 
 
  va_start (args, format);
  va_start (args, format);
 
 
  uo_field_fmt (uiout, fldno, width, align, fldname, format, args);
  uo_field_fmt (uiout, fldno, width, align, fldname, format, args);
 
 
  va_end (args);
  va_end (args);
}
}
 
 
void
void
ui_out_spaces (struct ui_out *uiout, int numspaces)
ui_out_spaces (struct ui_out *uiout, int numspaces)
{
{
  uo_spaces (uiout, numspaces);
  uo_spaces (uiout, numspaces);
}
}
 
 
void
void
ui_out_text (struct ui_out *uiout,
ui_out_text (struct ui_out *uiout,
             const char *string)
             const char *string)
{
{
  uo_text (uiout, string);
  uo_text (uiout, string);
}
}
 
 
void
void
ui_out_message (struct ui_out *uiout, int verbosity,
ui_out_message (struct ui_out *uiout, int verbosity,
                const char *format,...)
                const char *format,...)
{
{
  va_list args;
  va_list args;
 
 
  va_start (args, format);
  va_start (args, format);
 
 
  uo_message (uiout, verbosity, format, args);
  uo_message (uiout, verbosity, format, args);
 
 
  va_end (args);
  va_end (args);
}
}
 
 
struct ui_stream *
struct ui_stream *
ui_out_stream_new (struct ui_out *uiout)
ui_out_stream_new (struct ui_out *uiout)
{
{
  struct ui_stream *tempbuf;
  struct ui_stream *tempbuf;
 
 
  tempbuf = XMALLOC (struct ui_stream);
  tempbuf = XMALLOC (struct ui_stream);
  tempbuf->uiout = uiout;
  tempbuf->uiout = uiout;
  tempbuf->stream = mem_fileopen ();
  tempbuf->stream = mem_fileopen ();
  return tempbuf;
  return tempbuf;
}
}
 
 
void
void
ui_out_stream_delete (struct ui_stream *buf)
ui_out_stream_delete (struct ui_stream *buf)
{
{
  ui_file_delete (buf->stream);
  ui_file_delete (buf->stream);
  xfree (buf);
  xfree (buf);
}
}
 
 
static void
static void
do_stream_delete (void *buf)
do_stream_delete (void *buf)
{
{
  ui_out_stream_delete (buf);
  ui_out_stream_delete (buf);
}
}
 
 
struct cleanup *
struct cleanup *
make_cleanup_ui_out_stream_delete (struct ui_stream *buf)
make_cleanup_ui_out_stream_delete (struct ui_stream *buf)
{
{
  return make_cleanup (do_stream_delete, buf);
  return make_cleanup (do_stream_delete, buf);
}
}
 
 
 
 
void
void
ui_out_wrap_hint (struct ui_out *uiout, char *identstring)
ui_out_wrap_hint (struct ui_out *uiout, char *identstring)
{
{
  uo_wrap_hint (uiout, identstring);
  uo_wrap_hint (uiout, identstring);
}
}
 
 
void
void
ui_out_flush (struct ui_out *uiout)
ui_out_flush (struct ui_out *uiout)
{
{
  uo_flush (uiout);
  uo_flush (uiout);
}
}
 
 
int
int
ui_out_redirect (struct ui_out *uiout, struct ui_file *outstream)
ui_out_redirect (struct ui_out *uiout, struct ui_file *outstream)
{
{
  return uo_redirect (uiout, outstream);
  return uo_redirect (uiout, outstream);
}
}
 
 
/* set the flags specified by the mask given */
/* set the flags specified by the mask given */
int
int
ui_out_set_flags (struct ui_out *uiout, int mask)
ui_out_set_flags (struct ui_out *uiout, int mask)
{
{
  int oldflags = uiout->flags;
  int oldflags = uiout->flags;
 
 
  uiout->flags |= mask;
  uiout->flags |= mask;
 
 
  return oldflags;
  return oldflags;
}
}
 
 
/* clear the flags specified by the mask given */
/* clear the flags specified by the mask given */
int
int
ui_out_clear_flags (struct ui_out *uiout, int mask)
ui_out_clear_flags (struct ui_out *uiout, int mask)
{
{
  int oldflags = uiout->flags;
  int oldflags = uiout->flags;
 
 
  uiout->flags &= ~mask;
  uiout->flags &= ~mask;
 
 
  return oldflags;
  return oldflags;
}
}
 
 
/* test the flags against the mask given */
/* test the flags against the mask given */
int
int
ui_out_test_flags (struct ui_out *uiout, int mask)
ui_out_test_flags (struct ui_out *uiout, int mask)
{
{
  return (uiout->flags & mask);
  return (uiout->flags & mask);
}
}
 
 
/* obtain the current verbosity level (as stablished by the
/* obtain the current verbosity level (as stablished by the
   'set verbositylevel' command */
   'set verbositylevel' command */
 
 
int
int
ui_out_get_verblvl (struct ui_out *uiout)
ui_out_get_verblvl (struct ui_out *uiout)
{
{
  /* FIXME: not implemented yet */
  /* FIXME: not implemented yet */
  return 0;
  return 0;
}
}
 
 
#if 0
#if 0
void
void
ui_out_result_begin (struct ui_out *uiout, char *class)
ui_out_result_begin (struct ui_out *uiout, char *class)
{
{
}
}
 
 
void
void
ui_out_result_end (struct ui_out *uiout)
ui_out_result_end (struct ui_out *uiout)
{
{
}
}
 
 
void
void
ui_out_info_begin (struct ui_out *uiout, char *class)
ui_out_info_begin (struct ui_out *uiout, char *class)
{
{
}
}
 
 
void
void
ui_out_info_end (struct ui_out *uiout)
ui_out_info_end (struct ui_out *uiout)
{
{
}
}
 
 
void
void
ui_out_notify_begin (struct ui_out *uiout, char *class)
ui_out_notify_begin (struct ui_out *uiout, char *class)
{
{
}
}
 
 
void
void
ui_out_notify_end (struct ui_out *uiout)
ui_out_notify_end (struct ui_out *uiout)
{
{
}
}
 
 
void
void
ui_out_error_begin (struct ui_out *uiout, char *class)
ui_out_error_begin (struct ui_out *uiout, char *class)
{
{
}
}
 
 
void
void
ui_out_error_end (struct ui_out *uiout)
ui_out_error_end (struct ui_out *uiout)
{
{
}
}
#endif
#endif
 
 
#if 0
#if 0
void
void
gdb_error (ui_out * uiout, int severity, char *format,...)
gdb_error (ui_out * uiout, int severity, char *format,...)
{
{
  va_list args;
  va_list args;
}
}
 
 
void
void
gdb_query (struct ui_out *uiout, int qflags, char *qprompt)
gdb_query (struct ui_out *uiout, int qflags, char *qprompt)
{
{
}
}
#endif
#endif
 
 
int
int
ui_out_is_mi_like_p (struct ui_out *uiout)
ui_out_is_mi_like_p (struct ui_out *uiout)
{
{
  return uiout->impl->is_mi_like_p;
  return uiout->impl->is_mi_like_p;
}
}
 
 
/* default gdb-out hook functions */
/* default gdb-out hook functions */
 
 
static void
static void
default_table_begin (struct ui_out *uiout, int nbrofcols,
default_table_begin (struct ui_out *uiout, int nbrofcols,
                     int nr_rows,
                     int nr_rows,
                     const char *tblid)
                     const char *tblid)
{
{
}
}
 
 
static void
static void
default_table_body (struct ui_out *uiout)
default_table_body (struct ui_out *uiout)
{
{
}
}
 
 
static void
static void
default_table_end (struct ui_out *uiout)
default_table_end (struct ui_out *uiout)
{
{
}
}
 
 
static void
static void
default_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
default_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
                      const char *col_name,
                      const char *col_name,
                      const char *colhdr)
                      const char *colhdr)
{
{
}
}
 
 
static void
static void
default_begin (struct ui_out *uiout,
default_begin (struct ui_out *uiout,
               enum ui_out_type type,
               enum ui_out_type type,
               int level,
               int level,
               const char *id)
               const char *id)
{
{
}
}
 
 
static void
static void
default_end (struct ui_out *uiout,
default_end (struct ui_out *uiout,
             enum ui_out_type type,
             enum ui_out_type type,
             int level)
             int level)
{
{
}
}
 
 
static void
static void
default_field_int (struct ui_out *uiout, int fldno, int width,
default_field_int (struct ui_out *uiout, int fldno, int width,
                   enum ui_align align,
                   enum ui_align align,
                   const char *fldname, int value)
                   const char *fldname, int value)
{
{
}
}
 
 
static void
static void
default_field_skip (struct ui_out *uiout, int fldno, int width,
default_field_skip (struct ui_out *uiout, int fldno, int width,
                    enum ui_align align, const char *fldname)
                    enum ui_align align, const char *fldname)
{
{
}
}
 
 
static void
static void
default_field_string (struct ui_out *uiout,
default_field_string (struct ui_out *uiout,
                      int fldno,
                      int fldno,
                      int width,
                      int width,
                      enum ui_align align,
                      enum ui_align align,
                      const char *fldname,
                      const char *fldname,
                      const char *string)
                      const char *string)
{
{
}
}
 
 
static void
static void
default_field_fmt (struct ui_out *uiout, int fldno, int width,
default_field_fmt (struct ui_out *uiout, int fldno, int width,
                   enum ui_align align,
                   enum ui_align align,
                   const char *fldname,
                   const char *fldname,
                   const char *format,
                   const char *format,
                   va_list args)
                   va_list args)
{
{
}
}
 
 
static void
static void
default_spaces (struct ui_out *uiout, int numspaces)
default_spaces (struct ui_out *uiout, int numspaces)
{
{
}
}
 
 
static void
static void
default_text (struct ui_out *uiout, const char *string)
default_text (struct ui_out *uiout, const char *string)
{
{
}
}
 
 
static void
static void
default_message (struct ui_out *uiout, int verbosity,
default_message (struct ui_out *uiout, int verbosity,
                 const char *format,
                 const char *format,
                 va_list args)
                 va_list args)
{
{
}
}
 
 
static void
static void
default_wrap_hint (struct ui_out *uiout, char *identstring)
default_wrap_hint (struct ui_out *uiout, char *identstring)
{
{
}
}
 
 
static void
static void
default_flush (struct ui_out *uiout)
default_flush (struct ui_out *uiout)
{
{
}
}
 
 
/* Interface to the implementation functions */
/* Interface to the implementation functions */
 
 
void
void
uo_table_begin (struct ui_out *uiout, int nbrofcols,
uo_table_begin (struct ui_out *uiout, int nbrofcols,
                int nr_rows,
                int nr_rows,
                const char *tblid)
                const char *tblid)
{
{
  if (!uiout->impl->table_begin)
  if (!uiout->impl->table_begin)
    return;
    return;
  uiout->impl->table_begin (uiout, nbrofcols, nr_rows, tblid);
  uiout->impl->table_begin (uiout, nbrofcols, nr_rows, tblid);
}
}
 
 
void
void
uo_table_body (struct ui_out *uiout)
uo_table_body (struct ui_out *uiout)
{
{
  if (!uiout->impl->table_body)
  if (!uiout->impl->table_body)
    return;
    return;
  uiout->impl->table_body (uiout);
  uiout->impl->table_body (uiout);
}
}
 
 
void
void
uo_table_end (struct ui_out *uiout)
uo_table_end (struct ui_out *uiout)
{
{
  if (!uiout->impl->table_end)
  if (!uiout->impl->table_end)
    return;
    return;
  uiout->impl->table_end (uiout);
  uiout->impl->table_end (uiout);
}
}
 
 
void
void
uo_table_header (struct ui_out *uiout, int width, enum ui_align align,
uo_table_header (struct ui_out *uiout, int width, enum ui_align align,
                 const char *col_name,
                 const char *col_name,
                 const char *colhdr)
                 const char *colhdr)
{
{
  if (!uiout->impl->table_header)
  if (!uiout->impl->table_header)
    return;
    return;
  uiout->impl->table_header (uiout, width, align, col_name, colhdr);
  uiout->impl->table_header (uiout, width, align, col_name, colhdr);
}
}
 
 
void
void
uo_begin (struct ui_out *uiout,
uo_begin (struct ui_out *uiout,
          enum ui_out_type type,
          enum ui_out_type type,
          int level,
          int level,
          const char *id)
          const char *id)
{
{
  if (uiout->impl->begin == NULL)
  if (uiout->impl->begin == NULL)
    return;
    return;
  uiout->impl->begin (uiout, type, level, id);
  uiout->impl->begin (uiout, type, level, id);
}
}
 
 
void
void
uo_end (struct ui_out *uiout,
uo_end (struct ui_out *uiout,
        enum ui_out_type type,
        enum ui_out_type type,
        int level)
        int level)
{
{
  if (uiout->impl->end == NULL)
  if (uiout->impl->end == NULL)
    return;
    return;
  uiout->impl->end (uiout, type, level);
  uiout->impl->end (uiout, type, level);
}
}
 
 
void
void
uo_field_int (struct ui_out *uiout, int fldno, int width, enum ui_align align,
uo_field_int (struct ui_out *uiout, int fldno, int width, enum ui_align align,
              const char *fldname,
              const char *fldname,
              int value)
              int value)
{
{
  if (!uiout->impl->field_int)
  if (!uiout->impl->field_int)
    return;
    return;
  uiout->impl->field_int (uiout, fldno, width, align, fldname, value);
  uiout->impl->field_int (uiout, fldno, width, align, fldname, value);
}
}
 
 
void
void
uo_field_skip (struct ui_out *uiout, int fldno, int width, enum ui_align align,
uo_field_skip (struct ui_out *uiout, int fldno, int width, enum ui_align align,
               const char *fldname)
               const char *fldname)
{
{
  if (!uiout->impl->field_skip)
  if (!uiout->impl->field_skip)
    return;
    return;
  uiout->impl->field_skip (uiout, fldno, width, align, fldname);
  uiout->impl->field_skip (uiout, fldno, width, align, fldname);
}
}
 
 
void
void
uo_field_string (struct ui_out *uiout, int fldno, int width,
uo_field_string (struct ui_out *uiout, int fldno, int width,
                 enum ui_align align,
                 enum ui_align align,
                 const char *fldname,
                 const char *fldname,
                 const char *string)
                 const char *string)
{
{
  if (!uiout->impl->field_string)
  if (!uiout->impl->field_string)
    return;
    return;
  uiout->impl->field_string (uiout, fldno, width, align, fldname, string);
  uiout->impl->field_string (uiout, fldno, width, align, fldname, string);
}
}
 
 
void
void
uo_field_fmt (struct ui_out *uiout, int fldno, int width, enum ui_align align,
uo_field_fmt (struct ui_out *uiout, int fldno, int width, enum ui_align align,
              const char *fldname,
              const char *fldname,
              const char *format,
              const char *format,
              va_list args)
              va_list args)
{
{
  if (!uiout->impl->field_fmt)
  if (!uiout->impl->field_fmt)
    return;
    return;
  uiout->impl->field_fmt (uiout, fldno, width, align, fldname, format, args);
  uiout->impl->field_fmt (uiout, fldno, width, align, fldname, format, args);
}
}
 
 
void
void
uo_spaces (struct ui_out *uiout, int numspaces)
uo_spaces (struct ui_out *uiout, int numspaces)
{
{
  if (!uiout->impl->spaces)
  if (!uiout->impl->spaces)
    return;
    return;
  uiout->impl->spaces (uiout, numspaces);
  uiout->impl->spaces (uiout, numspaces);
}
}
 
 
void
void
uo_text (struct ui_out *uiout,
uo_text (struct ui_out *uiout,
         const char *string)
         const char *string)
{
{
  if (!uiout->impl->text)
  if (!uiout->impl->text)
    return;
    return;
  uiout->impl->text (uiout, string);
  uiout->impl->text (uiout, string);
}
}
 
 
void
void
uo_message (struct ui_out *uiout, int verbosity,
uo_message (struct ui_out *uiout, int verbosity,
            const char *format,
            const char *format,
            va_list args)
            va_list args)
{
{
  if (!uiout->impl->message)
  if (!uiout->impl->message)
    return;
    return;
  uiout->impl->message (uiout, verbosity, format, args);
  uiout->impl->message (uiout, verbosity, format, args);
}
}
 
 
void
void
uo_wrap_hint (struct ui_out *uiout, char *identstring)
uo_wrap_hint (struct ui_out *uiout, char *identstring)
{
{
  if (!uiout->impl->wrap_hint)
  if (!uiout->impl->wrap_hint)
    return;
    return;
  uiout->impl->wrap_hint (uiout, identstring);
  uiout->impl->wrap_hint (uiout, identstring);
}
}
 
 
void
void
uo_flush (struct ui_out *uiout)
uo_flush (struct ui_out *uiout)
{
{
  if (!uiout->impl->flush)
  if (!uiout->impl->flush)
    return;
    return;
  uiout->impl->flush (uiout);
  uiout->impl->flush (uiout);
}
}
 
 
int
int
uo_redirect (struct ui_out *uiout, struct ui_file *outstream)
uo_redirect (struct ui_out *uiout, struct ui_file *outstream)
{
{
  if (!uiout->impl->redirect)
  if (!uiout->impl->redirect)
    return -1;
    return -1;
  uiout->impl->redirect (uiout, outstream);
  uiout->impl->redirect (uiout, outstream);
  return 0;
  return 0;
}
}
 
 
/* local functions */
/* local functions */
 
 
/* list of column headers manipulation routines */
/* list of column headers manipulation routines */
 
 
static void
static void
clear_header_list (struct ui_out *uiout)
clear_header_list (struct ui_out *uiout)
{
{
  while (uiout->table.header_first != NULL)
  while (uiout->table.header_first != NULL)
    {
    {
      uiout->table.header_next = uiout->table.header_first;
      uiout->table.header_next = uiout->table.header_first;
      uiout->table.header_first = uiout->table.header_first->next;
      uiout->table.header_first = uiout->table.header_first->next;
      if (uiout->table.header_next->colhdr != NULL)
      if (uiout->table.header_next->colhdr != NULL)
        xfree (uiout->table.header_next->colhdr);
        xfree (uiout->table.header_next->colhdr);
      xfree (uiout->table.header_next);
      xfree (uiout->table.header_next);
    }
    }
  gdb_assert (uiout->table.header_first == NULL);
  gdb_assert (uiout->table.header_first == NULL);
  uiout->table.header_last = NULL;
  uiout->table.header_last = NULL;
  uiout->table.header_next = NULL;
  uiout->table.header_next = NULL;
}
}
 
 
static void
static void
append_header_to_list (struct ui_out *uiout,
append_header_to_list (struct ui_out *uiout,
                       int width,
                       int width,
                       int alignment,
                       int alignment,
                       const char *col_name,
                       const char *col_name,
                       const char *colhdr)
                       const char *colhdr)
{
{
  struct ui_out_hdr *temphdr;
  struct ui_out_hdr *temphdr;
 
 
  temphdr = XMALLOC (struct ui_out_hdr);
  temphdr = XMALLOC (struct ui_out_hdr);
  temphdr->width = width;
  temphdr->width = width;
  temphdr->alignment = alignment;
  temphdr->alignment = alignment;
  /* We have to copy the column title as the original may be an
  /* We have to copy the column title as the original may be an
     automatic.  */
     automatic.  */
  if (colhdr != NULL)
  if (colhdr != NULL)
    temphdr->colhdr = xstrdup (colhdr);
    temphdr->colhdr = xstrdup (colhdr);
  else
  else
    temphdr->colhdr = NULL;
    temphdr->colhdr = NULL;
 
 
  if (col_name != NULL)
  if (col_name != NULL)
    temphdr->col_name = xstrdup (col_name);
    temphdr->col_name = xstrdup (col_name);
  else if (colhdr != NULL)
  else if (colhdr != NULL)
    temphdr->col_name = xstrdup (colhdr);
    temphdr->col_name = xstrdup (colhdr);
  else
  else
    temphdr->col_name = NULL;
    temphdr->col_name = NULL;
 
 
  temphdr->next = NULL;
  temphdr->next = NULL;
  if (uiout->table.header_first == NULL)
  if (uiout->table.header_first == NULL)
    {
    {
      temphdr->colno = 1;
      temphdr->colno = 1;
      uiout->table.header_first = temphdr;
      uiout->table.header_first = temphdr;
      uiout->table.header_last = temphdr;
      uiout->table.header_last = temphdr;
    }
    }
  else
  else
    {
    {
      temphdr->colno = uiout->table.header_last->colno + 1;
      temphdr->colno = uiout->table.header_last->colno + 1;
      uiout->table.header_last->next = temphdr;
      uiout->table.header_last->next = temphdr;
      uiout->table.header_last = temphdr;
      uiout->table.header_last = temphdr;
    }
    }
  uiout->table.header_next = uiout->table.header_last;
  uiout->table.header_next = uiout->table.header_last;
}
}
 
 
/* Extract the format information for the NEXT header and and advance
/* Extract the format information for the NEXT header and and advance
   the header pointer.  Return 0 if there was no next header.  */
   the header pointer.  Return 0 if there was no next header.  */
 
 
static int
static int
get_next_header (struct ui_out *uiout,
get_next_header (struct ui_out *uiout,
                 int *colno,
                 int *colno,
                 int *width,
                 int *width,
                 int *alignment,
                 int *alignment,
                 char **colhdr)
                 char **colhdr)
{
{
  /* There may be no headers at all or we may have used all columns.  */
  /* There may be no headers at all or we may have used all columns.  */
  if (uiout->table.header_next == NULL)
  if (uiout->table.header_next == NULL)
    return 0;
    return 0;
  *colno = uiout->table.header_next->colno;
  *colno = uiout->table.header_next->colno;
  *width = uiout->table.header_next->width;
  *width = uiout->table.header_next->width;
  *alignment = uiout->table.header_next->alignment;
  *alignment = uiout->table.header_next->alignment;
  *colhdr = uiout->table.header_next->colhdr;
  *colhdr = uiout->table.header_next->colhdr;
  /* Advance the header pointer to the next entry.  */
  /* Advance the header pointer to the next entry.  */
  uiout->table.header_next = uiout->table.header_next->next;
  uiout->table.header_next = uiout->table.header_next->next;
  return 1;
  return 1;
}
}
 
 
 
 
/* Verify that the field/tuple/list is correctly positioned.  Return
/* Verify that the field/tuple/list is correctly positioned.  Return
   the field number and corresponding alignment (if
   the field number and corresponding alignment (if
   available/applicable).  */
   available/applicable).  */
 
 
static void
static void
verify_field (struct ui_out *uiout, int *fldno, int *width, int *align)
verify_field (struct ui_out *uiout, int *fldno, int *width, int *align)
{
{
  struct ui_out_level *current = current_level (uiout);
  struct ui_out_level *current = current_level (uiout);
  char *text;
  char *text;
 
 
  if (uiout->table.flag)
  if (uiout->table.flag)
    {
    {
      if (!uiout->table.body_flag)
      if (!uiout->table.body_flag)
        internal_error (__FILE__, __LINE__,
        internal_error (__FILE__, __LINE__,
                        _("table_body missing; table fields must be \
                        _("table_body missing; table fields must be \
specified after table_body and inside a list."));
specified after table_body and inside a list."));
      /* NOTE: cagney/2001-12-08: There was a check here to ensure
      /* NOTE: cagney/2001-12-08: There was a check here to ensure
         that this code was only executed when uiout->level was
         that this code was only executed when uiout->level was
         greater than zero.  That no longer applies - this code is run
         greater than zero.  That no longer applies - this code is run
         before each table row tuple is started and at that point the
         before each table row tuple is started and at that point the
         level is zero.  */
         level is zero.  */
    }
    }
 
 
  current->field_count += 1;
  current->field_count += 1;
 
 
  if (uiout->table.body_flag
  if (uiout->table.body_flag
      && uiout->table.entry_level == uiout->level
      && uiout->table.entry_level == uiout->level
      && get_next_header (uiout, fldno, width, align, &text))
      && get_next_header (uiout, fldno, width, align, &text))
    {
    {
      if (*fldno != current->field_count)
      if (*fldno != current->field_count)
        internal_error (__FILE__, __LINE__,
        internal_error (__FILE__, __LINE__,
                        _("ui-out internal error in handling headers."));
                        _("ui-out internal error in handling headers."));
    }
    }
  else
  else
    {
    {
      *width = 0;
      *width = 0;
      *align = ui_noalign;
      *align = ui_noalign;
      *fldno = current->field_count;
      *fldno = current->field_count;
    }
    }
}
}
 
 
 
 
/* access to ui_out format private members */
/* access to ui_out format private members */
 
 
void
void
ui_out_get_field_separator (struct ui_out *uiout)
ui_out_get_field_separator (struct ui_out *uiout)
{
{
}
}
 
 
/* Access to ui-out members data */
/* Access to ui-out members data */
 
 
struct ui_out_data *
struct ui_out_data *
ui_out_data (struct ui_out *uiout)
ui_out_data (struct ui_out *uiout)
{
{
  return uiout->data;
  return uiout->data;
}
}
 
 
/* initalize private members at startup */
/* initalize private members at startup */
 
 
struct ui_out *
struct ui_out *
ui_out_new (struct ui_out_impl *impl,
ui_out_new (struct ui_out_impl *impl,
            struct ui_out_data *data,
            struct ui_out_data *data,
            int flags)
            int flags)
{
{
  struct ui_out *uiout = XMALLOC (struct ui_out);
  struct ui_out *uiout = XMALLOC (struct ui_out);
  uiout->data = data;
  uiout->data = data;
  uiout->impl = impl;
  uiout->impl = impl;
  uiout->flags = flags;
  uiout->flags = flags;
  uiout->table.flag = 0;
  uiout->table.flag = 0;
  uiout->table.body_flag = 0;
  uiout->table.body_flag = 0;
  uiout->level = 0;
  uiout->level = 0;
  memset (uiout->levels, 0, sizeof (uiout->levels));
  memset (uiout->levels, 0, sizeof (uiout->levels));
  uiout->table.header_first = NULL;
  uiout->table.header_first = NULL;
  uiout->table.header_last = NULL;
  uiout->table.header_last = NULL;
  uiout->table.header_next = NULL;
  uiout->table.header_next = NULL;
  return uiout;
  return uiout;
}
}
 
 
/* standard gdb initialization hook */
/* standard gdb initialization hook */
 
 
void
void
_initialize_ui_out (void)
_initialize_ui_out (void)
{
{
  /* nothing needs to be done */
  /* nothing needs to be done */
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.