/* Output generating routines for GDB.
- Copyright 1999, 2000 Free Software Foundation, Inc.
+
+ Copyright (C) 1999-2019 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 "gdbsupport/format.h"
+#include "cli/cli-style.h"
+#include "diagnostics.h"
-/* Convenience macro for allocting typesafe memory. */
+#include <vector>
+#include <memory>
+#include <string>
-#undef XMALLOC
-#define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
+namespace {
-/* table header structures */
-
-struct ui_out_hdr
- {
- int colno;
- int width;
- int alignment;
- char *colhdr;
- struct ui_out_hdr *next;
- };
+/* A header of a ui_out_table. */
-/* The ui_out structure */
-/* Any change here requires a corresponding one in the initialization
- of the default uiout, which is statically initialized */
+class ui_out_hdr
+{
+ public:
-struct ui_out
+ 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 flags;
- /* specific implementation of ui-out */
- struct ui_out_impl *impl;
- struct ui_out_data *data;
+ }
- /* if on, a table is being generated */
- int table_flag;
+ int number () const
+ {
+ return m_number;
+ }
- /* if on, the body of a table is being generated */
- int body_flag;
+ int min_width () const
+ {
+ return m_min_width;
+ }
- /* number of table columns (as specified in the table_begin call) */
- int table_columns;
+ ui_align alignment () const
+ {
+ return m_alignment;
+ }
- /* strinf identifying the table (as specified in the table_begin call) */
- char *table_id;
+ const std::string &header () const
+ {
+ return m_header;
+ }
- /* if on, a list is being generated. The value is the level of nesting */
- int list_flag;
+ const std::string &name () const
+ {
+ return m_name;
+ }
- /* we count each field; the first element is for non-list fields */
- int field_count[5];
+ private:
- /* points to the first header (if any) */
- struct ui_out_hdr *headerfirst;
+ /* The number of the table column this header represents, 1-based. */
+ int m_number;
- /* points to the last header (if any) */
- struct ui_out_hdr *headerlast;
+ /* Minimal column width in characters. May or may not be applicable,
+ depending on the actual implementation of ui_out. */
+ int m_min_width;
- /* points to header of next column to format */
- struct ui_out_hdr *headercurr;
+ /* 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;
-/* These are the default implementation functions */
-
-static void default_table_begin (struct ui_out *uiout, int nbrofcols,
- 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, char *colhdr);
-static void default_list_begin (struct ui_out *uiout, int list_flag,
- char *lstid);
-static void default_list_end (struct ui_out *uiout, int list_flag);
-static void default_field_int (struct ui_out *uiout, int fldno, int width,
- enum ui_align alig, char *fldname, int value);
-static void default_field_skip (struct ui_out *uiout, int fldno, int width,
- enum ui_align alig, char *fldname);
-static void default_field_string (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, char *fldname,
- const char *string);
-static void default_field_fmt (struct ui_out *uiout, int fldno,
- int width, enum ui_align align,
- char *fldname, char *format, va_list args);
-static void default_spaces (struct ui_out *uiout, int numspaces);
-static void default_text (struct ui_out *uiout, char *string);
-static void default_message (struct ui_out *uiout, int verbosity, 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 =
-{
- default_table_begin,
- default_table_body,
- default_table_end,
- default_table_header,
- default_list_begin,
- default_list_end,
- default_field_int,
- default_field_skip,
- default_field_string,
- default_field_fmt,
- default_spaces,
- default_text,
- default_message,
- default_wrap_hint,
- default_flush
+ /* Printed header text of the column. */
+ std::string m_header;
};
-/* The default ui_out */
+} // namespace
+
+/* A level of nesting (either a list or a tuple) in a ui_out output. */
-struct ui_out def_uiout =
+class ui_out_level
{
- 0, /* flags */
- &default_ui_out_impl, /* impl */
-};
+ public:
-/* 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, 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, char *colhdr);
-static void uo_list_begin (struct ui_out *uiout, int list_flag, char *lstid);
-static void uo_list_end (struct ui_out *uiout, int list_flag);
-static void uo_field_int (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, char *fldname, int value);
-static void uo_field_skip (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, char *fldname);
-static void uo_field_string (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, char *fldname, const char *string);
-static void uo_field_fmt (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, char *fldname,
- char *format, va_list args);
-static void uo_spaces (struct ui_out *uiout, int numspaces);
-static void uo_text (struct ui_out *uiout, char *string);
-static void uo_message (struct ui_out *uiout, int verbosity,
- 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, char *colhdr);
-static int get_curr_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_proper_position (struct ui_out *uiout);
-static void verify_field_alignment (struct ui_out *uiout, int fldno, int *width, int *alignment);
-
-static void init_ui_out_state (struct ui_out *uiout);
-
-/* exported functions (ui_out API) */
-
-/* Mark beginning of a table */
+ explicit ui_out_level (ui_out_type type)
+ : m_type (type),
+ m_field_count (0)
+ {
+ }
-void
-ui_out_table_begin (uiout, nbrofcols, tblid)
- struct ui_out *uiout;
- int nbrofcols;
- char *tblid;
-{
- if (uiout->table_flag)
- internal_error ("gdb/ui_out.c: tables cannot be nested; table_begin found before \
-previous table_end.");
-
- uiout->table_flag = 1;
- uiout->table_columns = nbrofcols;
- if (tblid != NULL)
- uiout->table_id = xstrdup (tblid);
- else
- uiout->table_id = NULL;
- clear_header_list (uiout);
+ ui_out_type type () const
+ {
+ return m_type;
+ }
- uo_table_begin (uiout, nbrofcols, uiout->table_id);
-}
+ int field_count () const
+ {
+ return m_field_count;
+ }
-void
-ui_out_table_body (uiout)
- struct ui_out *uiout;
-{
- if (!uiout->table_flag)
- internal_error ("gdb/ui_out.c: table_body outside a table is not valid; it must be \
-after a table_begin and before a table_end.");
- if (uiout->body_flag)
- internal_error ("gdb/ui_out.c: extra table_body call not allowed; there must be \
-only one table_body after a table_begin and before a table_end.");
- if (uiout->headercurr->colno != uiout->table_columns)
- internal_error ("gdb/ui_out.c: number of headers differ from number of table \
-columns.");
+ void inc_field_count ()
+ {
+ m_field_count++;
+ }
- uiout->body_flag = 1;
- uiout->headercurr = uiout->headerfirst;
+ private:
- uo_table_body (uiout);
-}
+ /* The type of this level. */
+ ui_out_type m_type;
-void
-ui_out_table_end (uiout)
- struct ui_out *uiout;
-{
- if (!uiout->table_flag)
- internal_error ("gdb/ui_out.c: misplaced table_end or missing table_begin.");
+ /* Count each field; the first element is for non-list fields. */
+ int m_field_count;
+};
- uiout->body_flag = 0;
- uiout->table_flag = 0;
+/* 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. */
- uo_table_end (uiout);
+class ui_out_table
+{
+ public:
- if (uiout->table_id)
- free (uiout->table_id);
- clear_header_list (uiout);
-}
+ /* States (steps) of a table generation. */
-void
-ui_out_table_header (uiout, width, alignment, colhdr)
- struct ui_out *uiout;
- int width;
- enum ui_align alignment;
- char *colhdr;
-{
- if (!uiout->table_flag || uiout->body_flag)
- internal_error ("ui_out: table header must be specified after table_begin \
-and before table_body.");
+ enum class state
+ {
+ /* We are generating the table headers. */
+ HEADERS,
- append_header_to_list (uiout, width, alignment, colhdr);
+ /* We are generating the table body. */
+ BODY,
+ };
- uo_table_header (uiout, width, alignment, colhdr);
-}
+ 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)
+ {
+ }
-void
-ui_out_list_begin (uiout, lstid)
- struct ui_out *uiout;
- char *lstid;
-{
- if (uiout->table_flag && !uiout->body_flag)
- internal_error ("ui_out: table header or table_body expected; lists must be \
-specified after table_body.");
- if (uiout->list_flag >= 4)
- internal_error ("ui_out: list depth exceeded; only 4 levels of lists can be \
-nested.");
+ /* Start building the body of the table. */
- uiout->list_flag++;
- uiout->field_count[uiout->list_flag] = 0;
- if (uiout->table_flag && (uiout->list_flag == 1))
- uiout->headercurr = uiout->headerfirst;
+ void start_body ();
- uo_list_begin (uiout, uiout->list_flag, lstid);
-}
+ /* Add a new header to the table. */
-void
-ui_out_list_end (uiout)
- struct ui_out *uiout;
-{
- if (!uiout->list_flag)
- internal_error ("ui_out: misplaced list_end; there is no list to be closed.");
+ void append_header (int width, ui_align alignment,
+ const std::string &col_name, const std::string &col_hdr);
- uo_list_end (uiout, uiout->list_flag);
+ void start_row ();
- uiout->list_flag--;
-}
+ /* Extract the format information for the next header and advance
+ the header iterator. Return false if there was no next header. */
-void
-ui_out_field_int (uiout, fldname, value)
- struct ui_out *uiout;
- char *fldname;
- int value;
-{
- int fldno;
- int width;
- int align;
+ bool get_next_header (int *colno, int *width, ui_align *alignment,
+ const char **col_hdr);
- verify_field_proper_position (uiout);
+ bool query_field (int colno, int *width, int *alignment,
+ const char **col_name) const;
- uiout->field_count[uiout->list_flag] += 1;
- fldno = uiout->field_count[uiout->list_flag];
+ state current_state () const;
- verify_field_alignment (uiout, fldno, &width, &align);
+ int entry_level () const;
- uo_field_int (uiout, fldno, width, align, fldname, value);
-}
+ private:
-void
-ui_out_field_core_addr (uiout, fldname, address)
- struct ui_out *uiout;
- char *fldname;
- CORE_ADDR address;
-{
- char addstr[20];
+ state m_state;
- /* FIXME-32x64: need a print_address_numeric with field width */
- /* print_address_numeric (address, 1, local_stream); */
- strcpy (addstr, local_hex_string_custom ((unsigned long) address, "08l"));
+ /* 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 m_entry_level;
- ui_out_field_string (uiout, fldname, addstr);
-}
+ /* Number of table columns (as specified in the table_begin call). */
+ int m_nr_cols;
-void
-ui_out_field_stream (uiout, fldname, buf)
- struct ui_out *uiout;
- char *fldname;
- struct ui_stream *buf;
-{
- long length;
- char *buffer = ui_file_xstrdup (buf->stream, &length);
- struct cleanup *old_cleanup = make_cleanup (free, buffer);
- if (length > 0)
- ui_out_field_string (uiout, fldname, buffer);
- else
- ui_out_field_skip (uiout, fldname);
- ui_file_rewind (buf->stream);
- do_cleanups (old_cleanup);
-}
+ /* String identifying the table (as specified in the table_begin
+ call). */
+ std::string m_id;
-/* used to ommit a field */
+ /* Pointers to the column headers. */
+ std::vector<std::unique_ptr<ui_out_hdr>> m_headers;
-void
-ui_out_field_skip (uiout, fldname)
- struct ui_out *uiout;
- char *fldname;
-{
- int fldno;
- int width;
- int align;
+ /* Iterator over the headers vector, used when printing successive fields. */
+ std::vector<std::unique_ptr<ui_out_hdr>>::const_iterator m_headers_iterator;
+};
- verify_field_proper_position (uiout);
+/* See ui-out.h. */
- uiout->field_count[uiout->list_flag] += 1;
- fldno = uiout->field_count[uiout->list_flag];
+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."));
- verify_field_alignment (uiout, fldno, &width, &align);
+ /* 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."));
- uo_field_skip (uiout, fldno, width, align, fldname);
+ m_state = state::BODY;
+ m_headers_iterator = m_headers.begin ();
}
-void
-ui_out_field_string (struct ui_out *uiout,
- char *fldname,
- const char *string)
+/* See ui-out.h. */
+
+void ui_out_table::append_header (int width, ui_align alignment,
+ const std::string &col_name,
+ const std::string &col_hdr)
{
- int fldno;
- int width;
- int align;
+ if (m_state != state::HEADERS)
+ internal_error (__FILE__, __LINE__,
+ _("table header must be specified after table_begin and "
+ "before table_body."));
- verify_field_proper_position (uiout);
+ std::unique_ptr<ui_out_hdr> header (new ui_out_hdr (m_headers.size () + 1,
+ width, alignment,
+ col_name, col_hdr));
- uiout->field_count[uiout->list_flag] += 1;
- fldno = uiout->field_count[uiout->list_flag];
+ m_headers.push_back (std::move (header));
+}
- verify_field_alignment (uiout, fldno, &width, &align);
+/* See ui-out.h. */
- uo_field_string (uiout, fldno, width, align, fldname, string);
+void ui_out_table::start_row ()
+{
+ m_headers_iterator = m_headers.begin ();
}
-/* VARARGS */
-void
-ui_out_field_fmt (struct ui_out *uiout, char *fldname, char *format,...)
-{
- va_list args;
- int fldno;
- int width;
- int align;
+/* See ui-out.h. */
- verify_field_proper_position (uiout);
+bool ui_out_table::get_next_header (int *colno, int *width, ui_align *alignment,
+ const char **col_hdr)
+{
+ /* There may be no headers at all or we may have used all columns. */
+ if (m_headers_iterator == m_headers.end ())
+ return false;
- uiout->field_count[uiout->list_flag] += 1;
- fldno = uiout->field_count[uiout->list_flag];
+ ui_out_hdr *hdr = m_headers_iterator->get ();
- /* will not align, but has to call anyway */
- verify_field_alignment (uiout, fldno, &width, &align);
+ *colno = hdr->number ();
+ *width = hdr->min_width ();
+ *alignment = hdr->alignment ();
+ *col_hdr = hdr->header ().c_str ();
- va_start (args, format);
+ /* Advance the header pointer to the next entry. */
+ m_headers_iterator++;
- uo_field_fmt (uiout, fldno, width, align, fldname, format, args);
-
- va_end (args);
+ return true;
}
-void
-ui_out_spaces (uiout, numspaces)
- struct ui_out *uiout;
- int numspaces;
-{
- uo_spaces (uiout, numspaces);
-}
+/* See ui-out.h. */
-void
-ui_out_text (uiout, string)
- struct ui_out *uiout;
- char *string;
+bool ui_out_table::query_field (int colno, int *width, int *alignment,
+ const char **col_name) const
{
- uo_text (uiout, string);
-}
+ /* Column numbers are 1-based, so convert to 0-based index. */
+ int index = colno - 1;
-void
-ui_out_message (struct ui_out *uiout, int verbosity, char *format,...)
-{
- va_list args;
+ if (index >= 0 && index < m_headers.size ())
+ {
+ ui_out_hdr *hdr = m_headers[index].get ();
- va_start (args, format);
+ gdb_assert (colno == hdr->number ());
- uo_message (uiout, verbosity, format, args);
+ *width = hdr->min_width ();
+ *alignment = hdr->alignment ();
+ *col_name = hdr->name ().c_str ();
- va_end (args);
+ return true;
+ }
+ else
+ return false;
}
-struct ui_stream *
-ui_out_stream_new (uiout)
- struct ui_out *uiout;
-{
- struct ui_stream *tempbuf;
-
- tempbuf = XMALLOC (struct ui_stream);
- tempbuf->uiout = uiout;
- tempbuf->stream = mem_fileopen ();
- return tempbuf;
-}
+/* See ui-out.h. */
-void
-ui_out_stream_delete (buf)
- struct ui_stream *buf;
+ui_out_table::state ui_out_table::current_state () const
{
- ui_file_delete (buf->stream);
- free (buf);
+ return m_state;
}
-static void
-do_stream_delete (void *buf)
+/* See ui-out.h. */
+
+int ui_out_table::entry_level () const
{
- ui_out_stream_delete (buf);
+ return m_entry_level;
}
-struct cleanup *
-make_cleanup_ui_out_stream_delete (struct ui_stream *buf)
+int
+ui_out::level () const
{
- return make_cleanup (do_stream_delete, buf);
+ return m_levels.size ();
}
+/* The current (inner most) level. */
-void
-ui_out_wrap_hint (uiout, identstring)
- struct ui_out *uiout;
- char *identstring;
+ui_out_level *
+ui_out::current_level () const
{
- uo_wrap_hint (uiout, identstring);
+ return m_levels.back ().get ();
}
+/* Create a new level, of TYPE. */
void
-ui_out_flush (uiout)
- struct ui_out *uiout;
+ui_out::push_level (ui_out_type type)
{
- uo_flush (uiout);
-}
-
-/* set the flags specified by the mask given */
-int
-ui_out_set_flags (uiout, mask)
- struct ui_out *uiout;
- int mask;
-{
- int oldflags = uiout->flags;
+ std::unique_ptr<ui_out_level> level (new ui_out_level (type));
- uiout->flags |= mask;
-
- return oldflags;
+ m_levels.push_back (std::move (level));
}
-/* clear the flags specified by the mask given */
-int
-ui_out_clear_flags (uiout, mask)
- struct ui_out *uiout;
- int mask;
+/* Discard the current level. TYPE is the type of the level being
+ discarded. */
+void
+ui_out::pop_level (ui_out_type type)
{
- int oldflags = uiout->flags;
+ /* We had better not underflow the buffer. */
+ gdb_assert (m_levels.size () > 0);
+ gdb_assert (current_level ()->type () == type);
- uiout->flags &= ~mask;
-
- return oldflags;
+ m_levels.pop_back ();
}
-/* test the flags against the mask given */
-int
-ui_out_test_flags (uiout, mask)
- struct ui_out *uiout;
- int mask;
+/* Mark beginning of a table. */
+
+void
+ui_out::table_begin (int nr_cols, int nr_rows, const std::string &tblid)
{
- return (uiout->flags & mask);
-}
+ if (m_table_up != nullptr)
+ internal_error (__FILE__, __LINE__,
+ _("tables cannot be nested; table_begin found before \
+previous table_end."));
-/* obtain the current verbosity level (as stablished by the
- 'set verbositylevel' command */
+ m_table_up.reset (new ui_out_table (level () + 1, nr_cols, tblid));
-int
-ui_out_get_verblvl (uiout)
- struct ui_out *uiout;
-{
- /* FIXME: not implemented yet */
- return 0;
+ do_table_begin (nr_cols, nr_rows, tblid.c_str ());
}
-#if 0
void
-ui_out_result_begin (uiout, class)
- struct ui_out *uiout;
- char *class;
+ui_out::table_header (int width, ui_align alignment,
+ const std::string &col_name, const std::string &col_hdr)
{
-}
+ if (m_table_up == nullptr)
+ internal_error (__FILE__, __LINE__,
+ _("table_header outside a table is not valid; it must be \
+after a table_begin and before a table_body."));
-void
-ui_out_result_end (uiout)
- struct ui_out *uiout;
-{
-}
+ m_table_up->append_header (width, alignment, col_name, col_hdr);
-void
-ui_out_info_begin (uiout, class)
- struct ui_out *uiout;
- char *class;
-{
+ do_table_header (width, alignment, col_name, col_hdr);
}
void
-ui_out_info_end (uiout)
- struct ui_out *uiout;
+ui_out::table_body ()
{
-}
+ if (m_table_up == nullptr)
+ internal_error (__FILE__, __LINE__,
+ _("table_body outside a table is not valid; it must be "
+ "after a table_begin and before a table_end."));
-void
-ui_out_notify_begin (uiout, class)
- struct ui_out *uiout;
- char *class;
-{
-}
+ m_table_up->start_body ();
-void
-ui_out_notify_end (uiout)
- struct ui_out *uiout;
-{
+ do_table_body ();
}
void
-ui_out_error_begin (uiout, class)
- struct ui_out *uiout;
- char *class;
+ui_out::table_end ()
{
-}
+ if (m_table_up == nullptr)
+ internal_error (__FILE__, __LINE__,
+ _("misplaced table_end or missing table_begin."));
-void
-ui_out_error_end (uiout)
- struct ui_out *uiout;
-{
-}
-#endif
+ do_table_end ();
-#if 0
-void
-gdb_error (ui_out * uiout, int severity, char *format,...)
-{
- va_list args;
+ m_table_up = nullptr;
}
void
-gdb_query (uiout, qflags, qprompt)
- struct ui_out *uiout;
- int flags;
- char *qprompt;
+ui_out::begin (ui_out_type type, const char *id)
{
-}
-#endif
+ /* 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
+ is needed (at least) for the case where a table row entry
+ contains either a tuple/list. For that case bookkeeping such as
+ updating the column count or advancing to the next heading still
+ needs to be performed. */
+ {
+ int fldno;
+ int width;
+ ui_align align;
-/* default gdb-out hook functions */
+ verify_field (&fldno, &width, &align);
+ }
-static void
-default_table_begin (uiout, nbrofcols, tblid)
- struct ui_out *uiout;
- int nbrofcols;
- char *tblid;
-{
-}
+ push_level (type);
-static void
-default_table_body (uiout)
- struct ui_out *uiout;
-{
-}
+ /* 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 (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 ();
-static void
-default_table_end (uiout)
- struct ui_out *uiout;
-{
+ do_begin (type, id);
}
-static void
-default_table_header (uiout, width, alignment, colhdr)
- struct ui_out *uiout;
- int width;
- enum ui_align alignment;
- char *colhdr;
+void
+ui_out::end (ui_out_type type)
{
-}
+ pop_level (type);
-static void
-default_list_begin (uiout, list_flag, lstid)
- struct ui_out *uiout;
- int list_flag;
- char *lstid;
-{
+ do_end (type);
}
-static void
-default_list_end (uiout, list_flag)
- struct ui_out *uiout;
- int list_flag;
+void
+ui_out::field_signed (const char *fldname, LONGEST value)
{
-}
+ int fldno;
+ int width;
+ ui_align align;
-static void
-default_field_int (uiout, fldno, width, align, fldname, value)
- struct ui_out *uiout;
- int fldno;
- int width;
- enum ui_align align;
- char *fldname;
- int value;
-{
-}
+ verify_field (&fldno, &width, &align);
-static void
-default_field_skip (uiout, fldno, width, align, fldname)
- struct ui_out *uiout;
- int fldno;
- int width;
- enum ui_align align;
- char *fldname;
-{
+ do_field_signed (fldno, width, align, fldname, value);
}
-static void
-default_field_string (struct ui_out *uiout,
- int fldno,
- int width,
- enum ui_align align,
- char *fldname,
- const char *string)
+void
+ui_out::field_fmt_signed (int input_width, ui_align input_align,
+ const char *fldname, LONGEST value)
{
-}
+ int fldno;
+ int width;
+ ui_align align;
-static void
-default_field_fmt (uiout, fldno, width, align, fldname, format, args)
- struct ui_out *uiout;
- int fldno;
- int width;
- enum ui_align align;
- char *fldname;
- char *format;
- va_list args;
-{
-}
+ verify_field (&fldno, &width, &align);
-static void
-default_spaces (uiout, numspaces)
- struct ui_out *uiout;
- int numspaces;
-{
+ do_field_signed (fldno, input_width, input_align, fldname, value);
}
-static void
-default_text (uiout, string)
- struct ui_out *uiout;
- char *string;
-{
-}
+/* See ui-out.h. */
-static void
-default_message (uiout, verbosity, format, args)
- struct ui_out *uiout;
- int verbosity;
- char *format;
- va_list args;
+void
+ui_out::field_unsigned (const char *fldname, ULONGEST value)
{
-}
+ int fldno;
+ int width;
+ ui_align align;
-static void
-default_wrap_hint (uiout, identstring)
- struct ui_out *uiout;
- char *identstring;
-{
-}
+ verify_field (&fldno, &width, &align);
-static void
-default_flush (uiout)
- struct ui_out *uiout;
-{
+ do_field_unsigned (fldno, width, align, fldname, value);
}
-/* Interface to the implementation functions */
+/* Documented in ui-out.h. */
void
-uo_table_begin (struct ui_out *uiout, int nbrofcols, char *tblid)
+ui_out::field_core_addr (const char *fldname, struct gdbarch *gdbarch,
+ CORE_ADDR address)
{
- if (!uiout->impl->table_begin)
- return;
- uiout->impl->table_begin (uiout, nbrofcols, tblid);
+ field_string (fldname, print_core_address (gdbarch, address),
+ address_style.style ());
}
void
-uo_table_body (struct ui_out *uiout)
+ui_out::field_stream (const char *fldname, string_file &stream,
+ const ui_file_style &style)
{
- if (!uiout->impl->table_body)
- return;
- uiout->impl->table_body (uiout);
+ if (!stream.empty ())
+ field_string (fldname, stream.c_str (), style);
+ else
+ field_skip (fldname);
+ stream.clear ();
}
+/* Used to omit a field. */
+
void
-uo_table_end (struct ui_out *uiout)
+ui_out::field_skip (const char *fldname)
{
- if (!uiout->impl->table_end)
- return;
- uiout->impl->table_end (uiout);
+ int fldno;
+ int width;
+ ui_align align;
+
+ verify_field (&fldno, &width, &align);
+
+ do_field_skip (fldno, width, align, fldname);
}
void
-uo_table_header (struct ui_out *uiout, int width, enum ui_align align, char *colhdr)
+ui_out::field_string (const char *fldname, const char *string,
+ const ui_file_style &style)
{
- if (!uiout->impl->table_header)
- return;
- uiout->impl->table_header (uiout, width, align, colhdr);
+ int fldno;
+ int width;
+ ui_align align;
+
+ verify_field (&fldno, &width, &align);
+
+ do_field_string (fldno, width, align, fldname, string, style);
}
void
-uo_list_begin (struct ui_out *uiout, int list_flag, char *lstid)
+ui_out::field_string (const char *fldname, const std::string &string)
{
- if (!uiout->impl->list_begin)
- return;
- uiout->impl->list_begin (uiout, list_flag, lstid);
+ field_string (fldname, string.c_str ());
}
+/* VARARGS */
void
-uo_list_end (struct ui_out *uiout, int list_flag)
+ui_out::field_fmt (const char *fldname, const char *format, ...)
{
- if (!uiout->impl->list_end)
- return;
- uiout->impl->list_end (uiout, list_flag);
+ va_list args;
+ int fldno;
+ int width;
+ ui_align align;
+
+ verify_field (&fldno, &width, &align);
+
+ va_start (args, format);
+
+ do_field_fmt (fldno, width, align, fldname, ui_file_style (), format, args);
+
+ va_end (args);
}
void
-uo_field_int (struct ui_out *uiout, int fldno, int width, enum ui_align align, char *fldname, int value)
+ui_out::field_fmt (const char *fldname, const ui_file_style &style,
+ const char *format, ...)
{
- if (!uiout->impl->field_int)
- return;
- uiout->impl->field_int (uiout, fldno, width, align, fldname, value);
+ va_list args;
+ int fldno;
+ int width;
+ ui_align align;
+
+ verify_field (&fldno, &width, &align);
+
+ va_start (args, format);
+
+ do_field_fmt (fldno, width, align, fldname, style, format, args);
+
+ va_end (args);
}
void
-uo_field_skip (struct ui_out *uiout, int fldno, int width, enum ui_align align, char *fldname)
+ui_out::spaces (int numspaces)
{
- if (!uiout->impl->field_skip)
- return;
- uiout->impl->field_skip (uiout, fldno, width, align, fldname);
+ do_spaces (numspaces);
}
void
-uo_field_string (struct ui_out *uiout, int fldno, int width,
- enum ui_align align, char *fldname, const char *string)
+ui_out::text (const char *string)
{
- if (!uiout->impl->field_string)
- return;
- uiout->impl->field_string (uiout, fldno, width, align, fldname, string);
+ do_text (string);
}
void
-uo_field_fmt (struct ui_out *uiout, int fldno, int width, enum ui_align align, char *fldname, char *format, va_list args)
+ui_out::call_do_message (const ui_file_style &style, const char *format,
+ ...)
{
- if (!uiout->impl->field_fmt)
- return;
- uiout->impl->field_fmt (uiout, fldno, width, align, fldname, format, args);
+ va_list args;
+
+ va_start (args, format);
+
+ /* Since call_do_message is only used as a helper of vmessage, silence the
+ warning here once instead of at all call sites in vmessage, if we were
+ to put a "format" attribute on call_do_message. */
+ DIAGNOSTIC_PUSH
+ DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
+ do_message (style, format, args);
+ DIAGNOSTIC_POP
+
+ va_end (args);
}
void
-uo_spaces (struct ui_out *uiout, int numspaces)
+ui_out::vmessage (const ui_file_style &in_style, const char *format,
+ va_list args)
{
- if (!uiout->impl->spaces)
- return;
- uiout->impl->spaces (uiout, numspaces);
+ format_pieces fpieces (&format, true);
+
+ ui_file_style style = in_style;
+
+ for (auto &&piece : fpieces)
+ {
+ const char *current_substring = piece.string;
+
+ gdb_assert (piece.n_int_args >= 0 && piece.n_int_args <= 2);
+ int intvals[2] = { 0, 0 };
+ for (int i = 0; i < piece.n_int_args; ++i)
+ intvals[i] = va_arg (args, int);
+
+ /* The only ones we support for now. */
+ gdb_assert (piece.n_int_args == 0
+ || piece.argclass == string_arg
+ || piece.argclass == int_arg
+ || piece.argclass == long_arg);
+
+ switch (piece.argclass)
+ {
+ case string_arg:
+ {
+ const char *str = va_arg (args, const char *);
+ switch (piece.n_int_args)
+ {
+ case 0:
+ call_do_message (style, current_substring, str);
+ break;
+ case 1:
+ call_do_message (style, current_substring, intvals[0], str);
+ break;
+ case 2:
+ call_do_message (style, current_substring,
+ intvals[0], intvals[1], str);
+ break;
+ }
+ }
+ break;
+ case wide_string_arg:
+ gdb_assert_not_reached (_("wide_string_arg not supported in vmessage"));
+ break;
+ case wide_char_arg:
+ gdb_assert_not_reached (_("wide_char_arg not supported in vmessage"));
+ break;
+ case long_long_arg:
+ call_do_message (style, current_substring, va_arg (args, long long));
+ break;
+ case int_arg:
+ {
+ int val = va_arg (args, int);
+ switch (piece.n_int_args)
+ {
+ case 0:
+ call_do_message (style, current_substring, val);
+ break;
+ case 1:
+ call_do_message (style, current_substring, intvals[0], val);
+ break;
+ case 2:
+ call_do_message (style, current_substring,
+ intvals[0], intvals[1], val);
+ break;
+ }
+ }
+ break;
+ case long_arg:
+ {
+ long val = va_arg (args, long);
+ switch (piece.n_int_args)
+ {
+ case 0:
+ call_do_message (style, current_substring, val);
+ break;
+ case 1:
+ call_do_message (style, current_substring, intvals[0], val);
+ break;
+ case 2:
+ call_do_message (style, current_substring,
+ intvals[0], intvals[1], val);
+ break;
+ }
+ }
+ break;
+ case size_t_arg:
+ {
+ size_t val = va_arg (args, size_t);
+ switch (piece.n_int_args)
+ {
+ case 0:
+ call_do_message (style, current_substring, val);
+ break;
+ case 1:
+ call_do_message (style, current_substring, intvals[0], val);
+ break;
+ case 2:
+ call_do_message (style, current_substring,
+ intvals[0], intvals[1], val);
+ break;
+ }
+ }
+ break;
+ case double_arg:
+ call_do_message (style, current_substring, va_arg (args, double));
+ break;
+ case long_double_arg:
+ gdb_assert_not_reached (_("long_double_arg not supported in vmessage"));
+ break;
+ case dec32float_arg:
+ gdb_assert_not_reached (_("dec32float_arg not supported in vmessage"));
+ break;
+ case dec64float_arg:
+ gdb_assert_not_reached (_("dec64float_arg not supported in vmessage"));
+ break;
+ case dec128float_arg:
+ gdb_assert_not_reached (_("dec128float_arg not supported in vmessage"));
+ break;
+ case ptr_arg:
+ switch (current_substring[2])
+ {
+ case 'F':
+ {
+ gdb_assert (!test_flags (disallow_ui_out_field));
+ base_field_s *bf = va_arg (args, base_field_s *);
+ switch (bf->kind)
+ {
+ case field_kind::FIELD_SIGNED:
+ {
+ auto *f = (signed_field_s *) bf;
+ field_signed (f->name, f->val);
+ }
+ break;
+ case field_kind::FIELD_STRING:
+ {
+ auto *f = (string_field_s *) bf;
+ field_string (f->name, f->str);
+ }
+ break;
+ }
+ }
+ break;
+ case 's':
+ {
+ styled_string_s *ss = va_arg (args, styled_string_s *);
+ call_do_message (ss->style, "%s", ss->str);
+ }
+ break;
+ case '[':
+ style = *va_arg (args, const ui_file_style *);
+ break;
+ case ']':
+ {
+ void *arg = va_arg (args, void *);
+ gdb_assert (arg == nullptr);
+
+ style = {};
+ }
+ break;
+ default:
+ call_do_message (style, current_substring, va_arg (args, void *));
+ break;
+ }
+ break;
+ case literal_piece:
+ /* Print a portion of the format string that has no
+ directives. Note that this will not include any ordinary
+ %-specs, but it might include "%%". That is why we use
+ call_do_message here. Also, we pass a dummy argument
+ because some platforms have modified GCC to include
+ -Wformat-security by default, which will warn here if
+ there is no argument. */
+ call_do_message (style, current_substring, 0);
+ break;
+ default:
+ internal_error (__FILE__, __LINE__,
+ _("failed internal consistency check"));
+ }
+ }
}
void
-uo_text (struct ui_out *uiout, char *string)
+ui_out::message (const char *format, ...)
{
- if (!uiout->impl->text)
- return;
- uiout->impl->text (uiout, string);
+ va_list args;
+ va_start (args, format);
+
+ vmessage (ui_file_style (), format, args);
+
+ va_end (args);
}
void
-uo_message (struct ui_out *uiout, int verbosity, char *format, va_list args)
+ui_out::wrap_hint (const char *identstring)
{
- if (!uiout->impl->message)
- return;
- uiout->impl->message (uiout, verbosity, format, args);
+ do_wrap_hint (identstring);
}
void
-uo_wrap_hint (struct ui_out *uiout, char *identstring)
+ui_out::flush ()
{
- if (!uiout->impl->wrap_hint)
- return;
- uiout->impl->wrap_hint (uiout, identstring);
+ do_flush ();
}
void
-uo_flush (struct ui_out *uiout)
+ui_out::redirect (ui_file *outstream)
{
- if (!uiout->impl->flush)
- return;
- uiout->impl->flush (uiout);
+ do_redirect (outstream);
}
-/* local functions */
-
-/* list of column headers manipulation routines */
-
-static void
-clear_header_list (uiout)
- struct ui_out *uiout;
+/* Test the flags against the mask given. */
+ui_out_flags
+ui_out::test_flags (ui_out_flags mask)
{
- while (uiout->headerfirst != NULL)
- {
- uiout->headercurr = uiout->headerfirst;
- uiout->headerfirst = uiout->headerfirst->next;
- if (uiout->headercurr->colhdr != NULL)
- free (uiout->headercurr->colhdr);
- free (uiout->headercurr);
- }
- uiout->headerlast = NULL;
- uiout->headercurr = NULL;
+ return m_flags & mask;
}
-static void
-append_header_to_list (struct ui_out *uiout,
- int width,
- int alignment,
- char *colhdr)
+bool
+ui_out::is_mi_like_p () const
{
- 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 = xmalloc (strlen (colhdr) + 1);
- strcpy (temphdr->colhdr, colhdr);
- }
- temphdr->next = NULL;
- if (uiout->headerfirst == NULL)
- {
- temphdr->colno = 1;
- uiout->headerfirst = temphdr;
- uiout->headerlast = temphdr;
- }
- else
- {
- temphdr->colno = uiout->headerlast->colno + 1;
- uiout->headerlast->next = temphdr;
- uiout->headerlast = temphdr;
- }
- uiout->headercurr = uiout->headerlast;
+ return do_is_mi_like_p ();
}
-/* returns 0 if there is no more headers */
+/* Verify that the field/tuple/list is correctly positioned. Return
+ the field number and corresponding alignment (if
+ available/applicable). */
-static int
-get_curr_header (struct ui_out *uiout,
- int *colno,
- int *width,
- int *alignment,
- char **colhdr)
+void
+ui_out::verify_field (int *fldno, int *width, ui_align *align)
{
- /* There may be no headers at all or we may have used all columns */
- if (uiout->headercurr == NULL)
- return 0;
- *colno = uiout->headercurr->colno;
- *width = uiout->headercurr->width;
- *alignment = uiout->headercurr->alignment;
- *colhdr = uiout->headercurr->colhdr;
- uiout->headercurr = uiout->headercurr->next;
- return 1;
-}
-
-/* makes sure the field_* calls were properly placed */
+ ui_out_level *current = current_level ();
+ const char *text;
-static void
-verify_field_proper_position (struct ui_out *uiout)
-{
- if (uiout->table_flag)
+ if (m_table_up != nullptr
+ && m_table_up->current_state () != ui_out_table::state::BODY)
{
- if (!uiout->body_flag)
- internal_error ("ui_out: table_body missing; table fields must be \
-specified after table_body and inside a list.");
- if (!uiout->list_flag)
- internal_error ("ui_out: list_begin missing; table fields must be \
-specified after table_body and inside a list.");
+ internal_error (__FILE__, __LINE__,
+ _("table_body missing; table fields must be \
+specified after table_body and inside a list."));
}
-}
-
-/* determines what is the alignment policy */
-static void
-verify_field_alignment (struct ui_out *uiout,
- int fldno,
- int *width,
- int *align)
-{
- int colno;
- char *text;
+ current->inc_field_count ();
- if (uiout->table_flag
- && get_curr_header (uiout, &colno, 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 != colno)
- internal_error ("gdb/ui-out.c: ui-out internal error in handling headers.");
+ if (*fldno != current->field_count ())
+ internal_error (__FILE__, __LINE__,
+ _("ui-out internal error in handling headers."));
}
else
{
*width = 0;
*align = ui_noalign;
+ *fldno = current->field_count ();
}
}
-/* access to ui_out format private members */
+/* Access table field parameters. */
-void
-ui_out_get_field_separator (uiout)
- 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->body_flag = 0;
- uiout->list_flag = 0;
- uiout->field_count[0] = 0;
- uiout->headerfirst = NULL;
- uiout->headerlast = NULL;
- uiout->headercurr = 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 ()
+ui_out::~ui_out ()
{
- /* nothing needs to be done */
}
projects / deliverable / binutils-gdb.git / blobdiff