/* Output generating routines for GDB.
- Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1999-2017 Free Software Foundation, Inc.
Contributed by Cygnus Solutions.
Written by Fernando Nasser for Cygnus.
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
+ 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,
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. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_string.h"
#include "expression.h" /* For language.h */
#include "language.h"
#include "ui-out.h"
-#include "gdb_assert.h"
-/* table header structures */
+#include <vector>
+#include <memory>
+#include <string>
+#include <memory>
-struct ui_out_hdr
+namespace {
+
+/* A header of a ui_out_table. */
+
+class ui_out_hdr
+{
+ public:
+
+ explicit ui_out_hdr (int number, int min_width, ui_align alignment,
+ const std::string &name, const std::string &header)
+ : m_number (number),
+ m_min_width (min_width),
+ m_alignment (alignment),
+ m_name (name),
+ m_header (header)
{
- int colno;
- int width;
- int alignment;
- char *col_name;
- char *colhdr;
- struct ui_out_hdr *next;
- };
+ }
-/* Maintain a stack so that the info applicable to the inner most list
- is always available. Stack/nested level 0 is reserved for the
- top-level result. */
+ int number () const
+ {
+ return m_number;
+ }
-enum { MAX_UI_OUT_LEVELS = 6 };
+ int min_width () const
+ {
+ return m_min_width;
+ }
-struct ui_out_level
+ ui_align alignment () const
{
- /* Count each field; the first element is for non-list fields */
- int field_count;
- /* The type of this level. */
- enum ui_out_type type;
- };
+ return m_alignment;
+ }
+
+ const std::string &header () const
+ {
+ return m_header;
+ }
+
+ const std::string &name () const
+ {
+ return m_name;
+ }
+
+ private:
+
+ /* The number of the table column this header represents, 1-based. */
+ int m_number;
+
+ /* Minimal column width in characters. May or may not be applicable,
+ depending on the actual implementation of ui_out. */
+ int m_min_width;
+
+ /* Alignment of the content in the column. May or may not be applicable,
+ depending on the actual implementation of ui_out. */
+ ui_align m_alignment;
+
+ /* Internal column name, used to internally refer to the column. */
+ std::string m_name;
+
+ /* Printed header text of the column. */
+ std::string m_header;
+};
+
+} // namespace
+
+/* A level of nesting (either a list or a tuple) in a ui_out output. */
+
+class ui_out_level
+{
+ public:
+
+ explicit ui_out_level (ui_out_type type)
+ : m_type (type),
+ m_field_count (0)
+ {
+ }
+
+ ui_out_type type () const
+ {
+ return m_type;
+ }
+
+ int field_count () const
+ {
+ return m_field_count;
+ }
+
+ void inc_field_count ()
+ {
+ m_field_count++;
+ }
+
+ private:
+
+ /* The type of this level. */
+ ui_out_type m_type;
+
+ /* Count each field; the first element is for non-list fields. */
+ int m_field_count;
+};
/* Tables are special. Maintain a separate structure that tracks
their state. At present an output can only contain a single table
but that restriction might eventually be lifted. */
-struct ui_out_table
+class ui_out_table
{
- /* If on, a table is being generated. */
- int flag;
+ public:
+
+ /* States (steps) of a table generation. */
- /* If on, the body of a table is being generated. If off, the table
- header is being generated. */
- int body_flag;
+ enum class state
+ {
+ /* We are generating the table headers. */
+ HEADERS,
+
+ /* We are generating the table body. */
+ BODY,
+ };
+
+ explicit ui_out_table (int entry_level, int nr_cols, const std::string &id)
+ : m_state (state::HEADERS),
+ m_entry_level (entry_level),
+ m_nr_cols (nr_cols),
+ m_id (id)
+ {
+ }
+
+ /* Start building the body of the table. */
+
+ void start_body ();
+
+ /* Add a new header to the table. */
+
+ void append_header (int width, ui_align alignment,
+ const std::string &col_name, const std::string &col_hdr);
+
+ void start_row ();
+
+ /* Extract the format information for the next header and advance
+ the header iterator. Return false if there was no next header. */
+
+ bool get_next_header (int *colno, int *width, ui_align *alignment,
+ const char **col_hdr);
+
+ bool query_field (int colno, int *width, int *alignment,
+ const char **col_name) const;
+
+ state current_state () const;
+
+ int entry_level () const;
+
+ private:
+
+ state m_state;
/* 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
above that of the table. */
- int entry_level;
+ int m_entry_level;
/* Number of table columns (as specified in the table_begin call). */
- int columns;
+ int m_nr_cols;
/* String identifying the table (as specified in the table_begin
call). */
- char *id;
+ std::string m_id;
- /* Points to the first table header (if any). */
- struct ui_out_hdr *header_first;
+ /* Pointers to the column headers. */
+ std::vector<std::unique_ptr<ui_out_hdr>> m_headers;
- /* Points to the last table header (if any). */
- struct ui_out_hdr *header_last;
+ /* Iterator over the headers vector, used when printing successive fields. */
+ std::vector<std::unique_ptr<ui_out_hdr>>::const_iterator m_headers_iterator;
+};
- /* Points to header of NEXT column to format. */
- struct ui_out_hdr *header_next;
+/* See ui-out.h. */
-};
+void ui_out_table::start_body ()
+{
+ if (m_state != state::HEADERS)
+ internal_error (__FILE__, __LINE__,
+ _("extra table_body call not allowed; there must be only "
+ "one table_body after a table_begin and before a "
+ "table_end."));
+ /* Check if the number of defined headers matches the number of expected
+ columns. */
+ if (m_headers.size () != m_nr_cols)
+ internal_error (__FILE__, __LINE__,
+ _("number of headers differ from number of table "
+ "columns."));
-/* The ui_out structure */
-/* Any change here requires a corresponding one in the initialization
- of the default uiout, which is statically initialized */
+ m_state = state::BODY;
+ m_headers_iterator = m_headers.begin ();
+}
-struct ui_out
- {
- int flags;
- /* specific implementation of ui-out */
- struct ui_out_impl *impl;
- struct ui_out_data *data;
+/* See ui-out.h. */
- /* Sub structure tracking the ui-out depth. */
- int level;
- struct ui_out_level levels[MAX_UI_OUT_LEVELS];
+void ui_out_table::append_header (int width, ui_align alignment,
+ const std::string &col_name,
+ const std::string &col_hdr)
+{
+ if (m_state != state::HEADERS)
+ internal_error (__FILE__, __LINE__,
+ _("table header must be specified after table_begin and "
+ "before table_body."));
- /* A table, if any. At present only a single table is supported. */
- struct ui_out_table table;
- };
+ std::unique_ptr<ui_out_hdr> header (new ui_out_hdr (m_headers.size () + 1,
+ width, alignment,
+ col_name, col_hdr));
+
+ m_headers.push_back (std::move (header));
+}
+
+/* See ui-out.h. */
-/* The current (inner most) level. */
-static struct ui_out_level *
-current_level (struct ui_out *uiout)
+void ui_out_table::start_row ()
{
- return &uiout->levels[uiout->level];
+ m_headers_iterator = m_headers.begin ();
}
-/* Create a new level, of TYPE. Return the new level's index. */
-static int
-push_level (struct ui_out *uiout,
- enum ui_out_type type,
- const char *id)
+/* See ui-out.h. */
+
+bool ui_out_table::get_next_header (int *colno, int *width, ui_align *alignment,
+ const char **col_hdr)
{
- struct ui_out_level *current;
- /* We had better not overflow the buffer. */
- uiout->level++;
- gdb_assert (uiout->level >= 0 && uiout->level < MAX_UI_OUT_LEVELS);
- current = current_level (uiout);
- current->field_count = 0;
- current->type = type;
- return uiout->level;
+ /* There may be no headers at all or we may have used all columns. */
+ if (m_headers_iterator == m_headers.end ())
+ return false;
+
+ ui_out_hdr *hdr = m_headers_iterator->get ();
+
+ *colno = hdr->number ();
+ *width = hdr->min_width ();
+ *alignment = hdr->alignment ();
+ *col_hdr = hdr->header ().c_str ();
+
+ /* Advance the header pointer to the next entry. */
+ m_headers_iterator++;
+
+ return true;
}
-/* Discard the current level, return the discarded level's index.
- TYPE is the type of the level being discarded. */
-static int
-pop_level (struct ui_out *uiout,
- enum ui_out_type type)
+/* See ui-out.h. */
+
+bool ui_out_table::query_field (int colno, int *width, int *alignment,
+ const char **col_name) const
{
- /* We had better not underflow the buffer. */
- gdb_assert (uiout->level > 0 && uiout->level < MAX_UI_OUT_LEVELS);
- gdb_assert (current_level (uiout)->type == type);
- uiout->level--;
- return uiout->level + 1;
+ /* Column numbers are 1-based, so convert to 0-based index. */
+ int index = colno - 1;
+
+ if (index >= 0 && index < m_headers.size ())
+ {
+ ui_out_hdr *hdr = m_headers[index].get ();
+
+ gdb_assert (colno == hdr->number ());
+
+ *width = hdr->min_width ();
+ *alignment = hdr->alignment ();
+ *col_name = hdr->name ().c_str ();
+
+ return true;
+ }
+ else
+ return false;
}
+/* See ui-out.h. */
-/* These are the default implementation functions */
-
-static void default_table_begin (struct ui_out *uiout, int nbrofcols,
- int nr_rows, const char *tblid);
-static void default_table_body (struct ui_out *uiout);
-static void default_table_end (struct ui_out *uiout);
-static void default_table_header (struct ui_out *uiout, int width,
- enum ui_align alig, const char *col_name,
- const char *colhdr);
-static void default_begin (struct ui_out *uiout,
- enum ui_out_type type,
- int level, const char *id);
-static void default_end (struct ui_out *uiout,
- enum ui_out_type type,
- int level);
-static void default_field_int (struct ui_out *uiout, int fldno, int width,
- enum ui_align alig,
- const char *fldname,
- int value);
-static void default_field_skip (struct ui_out *uiout, int fldno, int width,
- enum ui_align alig,
- const char *fldname);
-static void default_field_string (struct ui_out *uiout, int fldno, int width,
- enum ui_align align,
- const char *fldname,
- const char *string);
-static void default_field_fmt (struct ui_out *uiout, int fldno,
- int width, enum ui_align align,
- const char *fldname,
- const char *format,
- va_list args);
-static void default_spaces (struct ui_out *uiout, int numspaces);
-static void default_text (struct ui_out *uiout, const char *string);
-static void default_message (struct ui_out *uiout, int verbosity,
- const char *format,
- va_list args);
-static void default_wrap_hint (struct ui_out *uiout, char *identstring);
-static void default_flush (struct ui_out *uiout);
-
-/* This is the default ui-out implementation functions vector */
-
-struct ui_out_impl default_ui_out_impl =
+ui_out_table::state ui_out_table::current_state () const
{
- default_table_begin,
- default_table_body,
- default_table_end,
- default_table_header,
- default_begin,
- default_end,
- default_field_int,
- default_field_skip,
- default_field_string,
- default_field_fmt,
- default_spaces,
- default_text,
- default_message,
- default_wrap_hint,
- default_flush,
- 0, /* Does not need MI hacks. */
-};
+ return m_state;
+}
-/* The default ui_out */
+/* See ui-out.h. */
-struct ui_out def_uiout =
+int ui_out_table::entry_level () const
{
- 0, /* flags */
- &default_ui_out_impl, /* impl */
-};
+ return m_entry_level;
+}
+
+int
+ui_out::level () const
+{
+ return m_levels.size ();
+}
-/* Pointer to current ui_out */
-/* FIXME: This should not be a global, but something passed down from main.c
- or top.c */
-
-struct ui_out *uiout = &def_uiout;
-
-/* These are the interfaces to implementation functions */
-
-static void uo_table_begin (struct ui_out *uiout, int nbrofcols,
- int nr_rows, const char *tblid);
-static void uo_table_body (struct ui_out *uiout);
-static void uo_table_end (struct ui_out *uiout);
-static void uo_table_header (struct ui_out *uiout, int width,
- enum ui_align align, const char *col_name,
- const char *colhdr);
-static void uo_begin (struct ui_out *uiout,
- enum ui_out_type type,
- int level, const char *id);
-static void uo_end (struct ui_out *uiout,
- enum ui_out_type type,
- int level);
-static void uo_field_int (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, const char *fldname, int value);
-static void uo_field_skip (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, const char *fldname);
-static void uo_field_string (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, const char *fldname,
- const char *string);
-static void uo_field_fmt (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, const char *fldname,
- const char *format, va_list args);
-static void uo_spaces (struct ui_out *uiout, int numspaces);
-static void uo_text (struct ui_out *uiout, const char *string);
-static void uo_message (struct ui_out *uiout, int verbosity,
- const char *format, va_list args);
-static void uo_wrap_hint (struct ui_out *uiout, char *identstring);
-static void uo_flush (struct ui_out *uiout);
-
-/* Prototypes for local functions */
-
-extern void _initialize_ui_out (void);
-static void append_header_to_list (struct ui_out *uiout, int width,
- int alignment, const char *col_name,
- const char *colhdr);
-static int get_next_header (struct ui_out *uiout, int *colno, int *width,
- int *alignment, char **colhdr);
-static void clear_header_list (struct ui_out *uiout);
-static void verify_field (struct ui_out *uiout, int *fldno, int *width,
- int *align);
-
-static void init_ui_out_state (struct ui_out *uiout);
-
-/* exported functions (ui_out API) */
-
-/* Mark beginning of a table */
+/* The current (inner most) level. */
+ui_out_level *
+ui_out::current_level () const
+{
+ return m_levels.back ().get ();
+}
+
+/* Create a new level, of TYPE. */
void
-ui_out_table_begin (struct ui_out *uiout, int nbrofcols,
- int nr_rows,
- const char *tblid)
+ui_out::push_level (ui_out_type type)
{
- if (uiout->table.flag)
- internal_error (__FILE__, __LINE__,
- "tables cannot be nested; table_begin found before \
-previous table_end.");
-
- uiout->table.flag = 1;
- uiout->table.body_flag = 0;
- uiout->table.entry_level = uiout->level + 1;
- uiout->table.columns = nbrofcols;
- if (tblid != NULL)
- uiout->table.id = xstrdup (tblid);
- else
- uiout->table.id = NULL;
- clear_header_list (uiout);
+ std::unique_ptr<ui_out_level> level (new ui_out_level (type));
- uo_table_begin (uiout, nbrofcols, nr_rows, uiout->table.id);
+ m_levels.push_back (std::move (level));
}
+/* Discard the current level. TYPE is the type of the level being
+ discarded. */
void
-ui_out_table_body (struct ui_out *uiout)
+ui_out::pop_level (ui_out_type type)
{
- if (!uiout->table.flag)
- internal_error (__FILE__, __LINE__,
- "table_body outside a table is not valid; it must be \
-after a table_begin and before a table_end.");
- if (uiout->table.body_flag)
- internal_error (__FILE__, __LINE__,
- "extra table_body call not allowed; there must be \
-only one table_body after a table_begin and before a table_end.");
- if (uiout->table.header_next->colno != uiout->table.columns)
+ /* We had better not underflow the buffer. */
+ gdb_assert (m_levels.size () > 0);
+ gdb_assert (current_level ()->type () == type);
+
+ m_levels.pop_back ();
+}
+
+/* Mark beginning of a table. */
+
+void
+ui_out::table_begin (int nr_cols, int nr_rows, const std::string &tblid)
+{
+ if (m_table_up != nullptr)
internal_error (__FILE__, __LINE__,
- "number of headers differ from number of table \
-columns.");
+ _("tables cannot be nested; table_begin found before \
+previous table_end."));
- uiout->table.body_flag = 1;
- uiout->table.header_next = uiout->table.header_first;
+ m_table_up.reset (new ui_out_table (level () + 1, nr_cols, tblid));
- uo_table_body (uiout);
+ do_table_begin (nr_cols, nr_rows, tblid.c_str ());
}
void
-ui_out_table_end (struct ui_out *uiout)
+ui_out::table_header (int width, ui_align alignment,
+ const std::string &col_name, const std::string &col_hdr)
{
- if (!uiout->table.flag)
+ if (m_table_up == nullptr)
internal_error (__FILE__, __LINE__,
- "misplaced table_end or missing table_begin.");
-
- uiout->table.entry_level = 0;
- uiout->table.body_flag = 0;
- uiout->table.flag = 0;
+ _("table_header outside a table is not valid; it must be \
+after a table_begin and before a table_body."));
- uo_table_end (uiout);
+ m_table_up->append_header (width, alignment, col_name, col_hdr);
- if (uiout->table.id)
- xfree (uiout->table.id);
- clear_header_list (uiout);
+ do_table_header (width, alignment, col_name, col_hdr);
}
void
-ui_out_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
- const char *col_name,
- const char *colhdr)
+ui_out::table_body ()
{
- if (!uiout->table.flag || uiout->table.body_flag)
+ if (m_table_up == nullptr)
internal_error (__FILE__, __LINE__,
- "table header must be specified after table_begin \
-and before table_body.");
+ _("table_body outside a table is not valid; it must be "
+ "after a table_begin and before a table_end."));
- append_header_to_list (uiout, width, alignment, col_name, colhdr);
+ m_table_up->start_body ();
- uo_table_header (uiout, width, alignment, col_name, colhdr);
+ do_table_body ();
}
void
-ui_out_begin (struct ui_out *uiout,
- enum ui_out_type type,
- const char *id)
+ui_out::table_end ()
{
- int new_level;
- if (uiout->table.flag && !uiout->table.body_flag)
+ if (m_table_up == nullptr)
internal_error (__FILE__, __LINE__,
- "table header or table_body expected; lists must be \
-specified after table_body.");
+ _("misplaced table_end or missing table_begin."));
+
+ do_table_end ();
+ m_table_up = nullptr;
+}
+
+void
+ui_out::begin (ui_out_type type, const char *id)
+{
/* Be careful to verify the ``field'' before the new tuple/list is
pushed onto the stack. That way the containing list/table/row is
verified and not the newly created tuple/list. This verification
{
int fldno;
int width;
- int align;
- verify_field (uiout, &fldno, &width, &align);
+ ui_align align;
+
+ verify_field (&fldno, &width, &align);
}
- new_level = push_level (uiout, type, id);
+ push_level (type);
/* 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. */
- if (uiout->table.body_flag
- && uiout->table.entry_level == new_level)
- uiout->table.header_next = uiout->table.header_first;
-
- uo_begin (uiout, type, new_level, id);
-}
+ if (m_table_up != nullptr
+ && m_table_up->current_state () == ui_out_table::state::BODY
+ && m_table_up->entry_level () == level ())
+ m_table_up->start_row ();
-void
-ui_out_list_begin (struct ui_out *uiout,
- const char *id)
-{
- ui_out_begin (uiout, ui_out_type_list, id);
+ do_begin (type, id);
}
void
-ui_out_tuple_begin (struct ui_out *uiout, const char *id)
+ui_out::end (ui_out_type type)
{
- ui_out_begin (uiout, ui_out_type_tuple, id);
-}
+ pop_level (type);
-void
-ui_out_end (struct ui_out *uiout,
- enum ui_out_type type)
-{
- int old_level = pop_level (uiout, type);
- uo_end (uiout, type, old_level);
-}
-
-void
-ui_out_list_end (struct ui_out *uiout)
-{
- ui_out_end (uiout, ui_out_type_list);
-}
-
-void
-ui_out_tuple_end (struct ui_out *uiout)
-{
- ui_out_end (uiout, ui_out_type_tuple);
+ do_end (type);
}
struct ui_out_end_cleanup_data
static void
do_cleanup_end (void *data)
{
- struct ui_out_end_cleanup_data *end_cleanup_data = data;
- ui_out_end (end_cleanup_data->uiout, end_cleanup_data->type);
+ struct ui_out_end_cleanup_data *end_cleanup_data
+ = (struct ui_out_end_cleanup_data *) data;
+
+ end_cleanup_data->uiout->end (end_cleanup_data->type);
xfree (end_cleanup_data);
}
enum ui_out_type type)
{
struct ui_out_end_cleanup_data *end_cleanup_data;
- end_cleanup_data = XMALLOC (struct ui_out_end_cleanup_data);
+
+ end_cleanup_data = XNEW (struct ui_out_end_cleanup_data);
end_cleanup_data->uiout = uiout;
end_cleanup_data->type = type;
return make_cleanup (do_cleanup_end, end_cleanup_data);
}
struct cleanup *
-make_cleanup_ui_out_begin_end (struct ui_out *uiout,
- enum ui_out_type type,
- const char *id)
-{
- ui_out_begin (uiout, type, id);
- return make_cleanup_ui_out_end (uiout, type);
-}
-
-struct cleanup *
make_cleanup_ui_out_tuple_begin_end (struct ui_out *uiout,
const char *id)
{
- ui_out_tuple_begin (uiout, id);
+ uiout->begin (ui_out_type_tuple, id);
return make_cleanup_ui_out_end (uiout, ui_out_type_tuple);
}
make_cleanup_ui_out_list_begin_end (struct ui_out *uiout,
const char *id)
{
- ui_out_list_begin (uiout, id);
+ uiout->begin (ui_out_type_list, id);
return make_cleanup_ui_out_end (uiout, ui_out_type_list);
}
void
-ui_out_field_int (struct ui_out *uiout,
- const char *fldname,
- int value)
+ui_out::field_int (const char *fldname, int value)
{
int fldno;
int width;
- int align;
- struct ui_out_level *current = current_level (uiout);
+ ui_align align;
- verify_field (uiout, &fldno, &width, &align);
+ verify_field (&fldno, &width, &align);
- uo_field_int (uiout, fldno, width, align, fldname, value);
+ do_field_int (fldno, width, align, fldname, value);
}
void
-ui_out_field_fmt_int (struct ui_out *uiout,
- int input_width,
- enum ui_align input_align,
- const char *fldname,
- int value)
+ui_out::field_fmt_int (int input_width, ui_align input_align,
+ const char *fldname, int value)
{
int fldno;
int width;
- int align;
- struct ui_out_level *current = current_level (uiout);
+ ui_align align;
- verify_field (uiout, &fldno, &width, &align);
+ verify_field (&fldno, &width, &align);
- uo_field_int (uiout, fldno, input_width, input_align, fldname, value);
+ do_field_int (fldno, input_width, input_align, fldname, value);
}
+/* Documented in ui-out.h. */
+
void
-ui_out_field_core_addr (struct ui_out *uiout,
- const char *fldname,
- CORE_ADDR address)
+ui_out::field_core_addr (const char *fldname, struct gdbarch *gdbarch,
+ CORE_ADDR address)
{
- char addstr[20];
-
- /* FIXME: cagney/2002-05-03: Need local_address_string() function
- that returns the language localized string formatted to a width
- based on TARGET_ADDR_BIT. */
- /* print_address_numeric (address, 1, local_stream); */
- if (TARGET_ADDR_BIT <= 32)
- strcpy (addstr, local_hex_string_custom (address, "08l"));
- else
- strcpy (addstr, local_hex_string_custom (address, "016l"));
-
- ui_out_field_string (uiout, fldname, addstr);
+ field_string (fldname, print_core_address (gdbarch, address));
}
void
-ui_out_field_stream (struct ui_out *uiout,
- const char *fldname,
- struct ui_stream *buf)
+ui_out::field_stream (const char *fldname, string_file &stream)
{
- long length;
- char *buffer = ui_file_xstrdup (buf->stream, &length);
- struct cleanup *old_cleanup = make_cleanup (xfree, buffer);
- if (length > 0)
- ui_out_field_string (uiout, fldname, buffer);
+ if (!stream.empty ())
+ field_string (fldname, stream.c_str ());
else
- ui_out_field_skip (uiout, fldname);
- ui_file_rewind (buf->stream);
- do_cleanups (old_cleanup);
+ field_skip (fldname);
+ stream.clear ();
}
-/* used to ommit a field */
+/* Used to omit a field. */
void
-ui_out_field_skip (struct ui_out *uiout,
- const char *fldname)
+ui_out::field_skip (const char *fldname)
{
int fldno;
int width;
- int align;
+ ui_align align;
- verify_field (uiout, &fldno, &width, &align);
+ verify_field (&fldno, &width, &align);
- uo_field_skip (uiout, fldno, width, align, fldname);
+ do_field_skip (fldno, width, align, fldname);
}
void
-ui_out_field_string (struct ui_out *uiout,
- const char *fldname,
- const char *string)
+ui_out::field_string (const char *fldname, const char *string)
{
int fldno;
int width;
- int align;
+ ui_align align;
- verify_field (uiout, &fldno, &width, &align);
+ verify_field (&fldno, &width, &align);
- uo_field_string (uiout, fldno, width, align, fldname, string);
+ do_field_string (fldno, width, align, fldname, string);
}
/* VARARGS */
void
-ui_out_field_fmt (struct ui_out *uiout,
- const char *fldname,
- const char *format, ...)
+ui_out::field_fmt (const char *fldname, const char *format, ...)
{
va_list args;
int fldno;
int width;
- int align;
+ ui_align align;
- /* will not align, but has to call anyway */
- verify_field (uiout, &fldno, &width, &align);
+ /* Will not align, but has to call anyway. */
+ verify_field (&fldno, &width, &align);
va_start (args, format);
- uo_field_fmt (uiout, fldno, width, align, fldname, format, args);
+ do_field_fmt (fldno, width, align, fldname, format, args);
va_end (args);
}
void
-ui_out_spaces (struct ui_out *uiout, int numspaces)
+ui_out::spaces (int numspaces)
{
- uo_spaces (uiout, numspaces);
+ do_spaces (numspaces);
}
void
-ui_out_text (struct ui_out *uiout,
- const char *string)
+ui_out::text (const char *string)
{
- uo_text (uiout, string);
+ do_text (string);
}
void
-ui_out_message (struct ui_out *uiout, int verbosity,
- const char *format,...)
+ui_out::message (const char *format, ...)
{
va_list args;
va_start (args, format);
-
- uo_message (uiout, verbosity, format, args);
-
+ do_message (format, args);
va_end (args);
}
-struct ui_stream *
-ui_out_stream_new (struct ui_out *uiout)
-{
- struct ui_stream *tempbuf;
-
- tempbuf = XMALLOC (struct ui_stream);
- tempbuf->uiout = uiout;
- tempbuf->stream = mem_fileopen ();
- return tempbuf;
-}
-
-void
-ui_out_stream_delete (struct ui_stream *buf)
-{
- ui_file_delete (buf->stream);
- xfree (buf);
-}
-
-static void
-do_stream_delete (void *buf)
-{
- ui_out_stream_delete (buf);
-}
-
-struct cleanup *
-make_cleanup_ui_out_stream_delete (struct ui_stream *buf)
-{
- return make_cleanup (do_stream_delete, buf);
-}
-
-
-void
-ui_out_wrap_hint (struct ui_out *uiout, char *identstring)
-{
- uo_wrap_hint (uiout, identstring);
-}
-
-void
-ui_out_flush (struct ui_out *uiout)
-{
- uo_flush (uiout);
-}
-
-/* set the flags specified by the mask given */
-int
-ui_out_set_flags (struct ui_out *uiout, int mask)
-{
- int oldflags = uiout->flags;
-
- uiout->flags |= mask;
-
- return oldflags;
-}
-
-/* clear the flags specified by the mask given */
-int
-ui_out_clear_flags (struct ui_out *uiout, int mask)
-{
- int oldflags = uiout->flags;
-
- uiout->flags &= ~mask;
-
- return oldflags;
-}
-
-/* test the flags against the mask given */
-int
-ui_out_test_flags (struct ui_out *uiout, int mask)
-{
- return (uiout->flags & mask);
-}
-
-/* obtain the current verbosity level (as stablished by the
- 'set verbositylevel' command */
-
-int
-ui_out_get_verblvl (struct ui_out *uiout)
-{
- /* FIXME: not implemented yet */
- return 0;
-}
-
-#if 0
-void
-ui_out_result_begin (struct ui_out *uiout, char *class)
-{
-}
-
-void
-ui_out_result_end (struct ui_out *uiout)
-{
-}
-
-void
-ui_out_info_begin (struct ui_out *uiout, char *class)
-{
-}
-
-void
-ui_out_info_end (struct ui_out *uiout)
-{
-}
-
-void
-ui_out_notify_begin (struct ui_out *uiout, char *class)
-{
-}
-
void
-ui_out_notify_end (struct ui_out *uiout)
+ui_out::wrap_hint (const char *identstring)
{
+ do_wrap_hint (identstring);
}
void
-ui_out_error_begin (struct ui_out *uiout, char *class)
+ui_out::flush ()
{
+ do_flush ();
}
void
-ui_out_error_end (struct ui_out *uiout)
+ui_out::redirect (ui_file *outstream)
{
+ do_redirect (outstream);
}
-#endif
-#if 0
-void
-gdb_error (ui_out * uiout, int severity, char *format,...)
-{
- va_list args;
-}
-
-void
-gdb_query (struct ui_out *uiout, int qflags, char *qprompt)
-{
-}
-#endif
-
-int
-ui_out_is_mi_like_p (struct ui_out *uiout)
-{
- return uiout->impl->is_mi_like_p;
-}
-
-/* default gdb-out hook functions */
-
-static void
-default_table_begin (struct ui_out *uiout, int nbrofcols,
- int nr_rows,
- const char *tblid)
-{
-}
-
-static void
-default_table_body (struct ui_out *uiout)
-{
-}
-
-static void
-default_table_end (struct ui_out *uiout)
+/* Test the flags against the mask given. */
+ui_out_flags
+ui_out::test_flags (ui_out_flags mask)
{
+ return m_flags & mask;
}
-static void
-default_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
- const char *col_name,
- const char *colhdr)
+bool
+ui_out::is_mi_like_p ()
{
+ return do_is_mi_like_p ();
}
-static void
-default_begin (struct ui_out *uiout,
- enum ui_out_type type,
- int level,
- const char *id)
-{
-}
-
-static void
-default_end (struct ui_out *uiout,
- enum ui_out_type type,
- int level)
-{
-}
-
-static void
-default_field_int (struct ui_out *uiout, int fldno, int width,
- enum ui_align align,
- const char *fldname, int value)
-{
-}
-
-static void
-default_field_skip (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, const char *fldname)
-{
-}
-
-static void
-default_field_string (struct ui_out *uiout,
- int fldno,
- int width,
- enum ui_align align,
- const char *fldname,
- const char *string)
-{
-}
-
-static void
-default_field_fmt (struct ui_out *uiout, int fldno, int width,
- enum ui_align align,
- const char *fldname,
- const char *format,
- va_list args)
-{
-}
-
-static void
-default_spaces (struct ui_out *uiout, int numspaces)
-{
-}
-
-static void
-default_text (struct ui_out *uiout, const char *string)
-{
-}
-
-static void
-default_message (struct ui_out *uiout, int verbosity,
- const char *format,
- va_list args)
-{
-}
-
-static void
-default_wrap_hint (struct ui_out *uiout, char *identstring)
-{
-}
-
-static void
-default_flush (struct ui_out *uiout)
-{
-}
-
-/* Interface to the implementation functions */
-
-void
-uo_table_begin (struct ui_out *uiout, int nbrofcols,
- int nr_rows,
- const char *tblid)
-{
- if (!uiout->impl->table_begin)
- return;
- uiout->impl->table_begin (uiout, nbrofcols, nr_rows, tblid);
-}
-
-void
-uo_table_body (struct ui_out *uiout)
-{
- if (!uiout->impl->table_body)
- return;
- uiout->impl->table_body (uiout);
-}
-
-void
-uo_table_end (struct ui_out *uiout)
-{
- if (!uiout->impl->table_end)
- return;
- uiout->impl->table_end (uiout);
-}
-
-void
-uo_table_header (struct ui_out *uiout, int width, enum ui_align align,
- const char *col_name,
- const char *colhdr)
-{
- if (!uiout->impl->table_header)
- return;
- uiout->impl->table_header (uiout, width, align, col_name, colhdr);
-}
-
-void
-uo_begin (struct ui_out *uiout,
- enum ui_out_type type,
- int level,
- const char *id)
-{
- if (uiout->impl->begin == NULL)
- return;
- uiout->impl->begin (uiout, type, level, id);
-}
-
-void
-uo_end (struct ui_out *uiout,
- enum ui_out_type type,
- int level)
-{
- if (uiout->impl->end == NULL)
- return;
- uiout->impl->end (uiout, type, level);
-}
-
-void
-uo_field_int (struct ui_out *uiout, int fldno, int width, enum ui_align align,
- const char *fldname,
- int value)
-{
- if (!uiout->impl->field_int)
- return;
- uiout->impl->field_int (uiout, fldno, width, align, fldname, value);
-}
-
-void
-uo_field_skip (struct ui_out *uiout, int fldno, int width, enum ui_align align,
- const char *fldname)
-{
- if (!uiout->impl->field_skip)
- return;
- uiout->impl->field_skip (uiout, fldno, width, align, fldname);
-}
-
-void
-uo_field_string (struct ui_out *uiout, int fldno, int width,
- enum ui_align align,
- const char *fldname,
- const char *string)
-{
- if (!uiout->impl->field_string)
- return;
- uiout->impl->field_string (uiout, fldno, width, align, fldname, string);
-}
-
-void
-uo_field_fmt (struct ui_out *uiout, int fldno, int width, enum ui_align align,
- const char *fldname,
- const char *format,
- va_list args)
-{
- if (!uiout->impl->field_fmt)
- return;
- uiout->impl->field_fmt (uiout, fldno, width, align, fldname, format, args);
-}
-
-void
-uo_spaces (struct ui_out *uiout, int numspaces)
-{
- if (!uiout->impl->spaces)
- return;
- uiout->impl->spaces (uiout, numspaces);
-}
-
-void
-uo_text (struct ui_out *uiout,
- const char *string)
-{
- if (!uiout->impl->text)
- return;
- uiout->impl->text (uiout, string);
-}
-
-void
-uo_message (struct ui_out *uiout, int verbosity,
- const char *format,
- va_list args)
-{
- if (!uiout->impl->message)
- return;
- uiout->impl->message (uiout, verbosity, format, args);
-}
-
-void
-uo_wrap_hint (struct ui_out *uiout, char *identstring)
-{
- if (!uiout->impl->wrap_hint)
- return;
- uiout->impl->wrap_hint (uiout, identstring);
-}
-
-void
-uo_flush (struct ui_out *uiout)
-{
- if (!uiout->impl->flush)
- return;
- uiout->impl->flush (uiout);
-}
-
-/* local functions */
-
-/* list of column headers manipulation routines */
-
-static void
-clear_header_list (struct ui_out *uiout)
-{
- while (uiout->table.header_first != NULL)
- {
- uiout->table.header_next = uiout->table.header_first;
- uiout->table.header_first = uiout->table.header_first->next;
- if (uiout->table.header_next->colhdr != NULL)
- xfree (uiout->table.header_next->colhdr);
- xfree (uiout->table.header_next);
- }
- gdb_assert (uiout->table.header_first == NULL);
- uiout->table.header_last = NULL;
- uiout->table.header_next = NULL;
-}
-
-static void
-append_header_to_list (struct ui_out *uiout,
- int width,
- int alignment,
- const char *col_name,
- const char *colhdr)
-{
- struct ui_out_hdr *temphdr;
-
- temphdr = XMALLOC (struct ui_out_hdr);
- temphdr->width = width;
- temphdr->alignment = alignment;
- /* we have to copy the column title as the original may be an automatic */
- if (colhdr != NULL)
- temphdr->colhdr = xstrdup (colhdr);
- else
- temphdr->colhdr = NULL;
- if (col_name != NULL)
- temphdr->col_name = xstrdup (colhdr);
- else
- temphdr->col_name = xstrdup (colhdr);
- temphdr->next = NULL;
- if (uiout->table.header_first == NULL)
- {
- temphdr->colno = 1;
- uiout->table.header_first = temphdr;
- uiout->table.header_last = temphdr;
- }
- else
- {
- temphdr->colno = uiout->table.header_last->colno + 1;
- uiout->table.header_last->next = temphdr;
- uiout->table.header_last = temphdr;
- }
- uiout->table.header_next = uiout->table.header_last;
-}
-
-/* Extract the format information for the NEXT header and and advance
- the header pointer. Return 0 if there was no next header. */
-
-static int
-get_next_header (struct ui_out *uiout,
- int *colno,
- int *width,
- int *alignment,
- char **colhdr)
-{
- /* There may be no headers at all or we may have used all columns. */
- if (uiout->table.header_next == NULL)
- return 0;
- *colno = uiout->table.header_next->colno;
- *width = uiout->table.header_next->width;
- *alignment = uiout->table.header_next->alignment;
- *colhdr = uiout->table.header_next->colhdr;
- /* Advance the header pointer to the next entry. */
- uiout->table.header_next = uiout->table.header_next->next;
- return 1;
-}
-
-
/* Verify that the field/tuple/list is correctly positioned. Return
the field number and corresponding alignment (if
available/applicable). */
-static void
-verify_field (struct ui_out *uiout, int *fldno, int *width, int *align)
+void
+ui_out::verify_field (int *fldno, int *width, ui_align *align)
{
- struct ui_out_level *current = current_level (uiout);
- char *text;
+ ui_out_level *current = current_level ();
+ const char *text;
- if (uiout->table.flag)
+ if (m_table_up != nullptr
+ && m_table_up->current_state () != ui_out_table::state::BODY)
{
- if (!uiout->table.body_flag)
- internal_error (__FILE__, __LINE__,
- "table_body missing; table fields must be \
-specified after table_body and inside a list.");
- /* NOTE: cagney/2001-12-08: There was a check here to ensure
- that this code was only executed when uiout->level was
- greater than zero. That no longer applies - this code is run
- before each table row tuple is started and at that point the
- level is zero. */
+ internal_error (__FILE__, __LINE__,
+ _("table_body missing; table fields must be \
+specified after table_body and inside a list."));
}
- current->field_count += 1;
+ current->inc_field_count ();
- if (uiout->table.body_flag
- && uiout->table.entry_level == uiout->level
- && get_next_header (uiout, fldno, width, align, &text))
+ if (m_table_up != nullptr
+ && m_table_up->current_state () == ui_out_table::state::BODY
+ && m_table_up->entry_level () == level ()
+ && m_table_up->get_next_header (fldno, width, align, &text))
{
- if (*fldno != current->field_count)
+ if (*fldno != current->field_count ())
internal_error (__FILE__, __LINE__,
- "ui-out internal error in handling headers.");
+ _("ui-out internal error in handling headers."));
}
else
{
*width = 0;
*align = ui_noalign;
- *fldno = current->field_count;
+ *fldno = current->field_count ();
}
}
+/* Access table field parameters. */
-/* access to ui_out format private members */
-
-void
-ui_out_get_field_separator (struct ui_out *uiout)
+bool
+ui_out::query_table_field (int colno, int *width, int *alignment,
+ const char **col_name)
{
-}
-
-/* Access to ui-out members data */
+ if (m_table_up == nullptr)
+ return false;
-struct ui_out_data *
-ui_out_data (struct ui_out *uiout)
-{
- return uiout->data;
+ return m_table_up->query_field (colno, width, alignment, col_name);
}
-/* initalize private members at startup */
+/* The constructor. */
-struct ui_out *
-ui_out_new (struct ui_out_impl *impl,
- struct ui_out_data *data,
- int flags)
+ui_out::ui_out (ui_out_flags flags)
+: m_flags (flags)
{
- struct ui_out *uiout = XMALLOC (struct ui_out);
- uiout->data = data;
- uiout->impl = impl;
- uiout->flags = flags;
- uiout->table.flag = 0;
- uiout->table.body_flag = 0;
- uiout->level = 0;
- memset (uiout->levels, 0, sizeof (uiout->levels));
- uiout->table.header_first = NULL;
- uiout->table.header_last = NULL;
- uiout->table.header_next = NULL;
- return uiout;
+ /* Create the ui-out level #1, the default level. */
+ push_level (ui_out_type_tuple);
}
-/* standard gdb initialization hook */
-
-void
-_initialize_ui_out (void)
+ui_out::~ui_out ()
{
- /* nothing needs to be done */
}