X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fosdata.c;h=2ff0f520b0b9e580490f5b3443b03755c2334403;hb=098caef485a4ece6096e6cdbb4cd9726e4a13386;hp=761f34ba53fa71b68e35f9d42193c18ed72b80d4;hpb=07e059b5a9cbdeab8bf2980e07e79f892a2da854;p=binutils-gdb.git diff --git a/gdb/osdata.c b/gdb/osdata.c index 761f34ba53f..2ff0f520b0b 100644 --- a/gdb/osdata.c +++ b/gdb/osdata.c @@ -1,6 +1,6 @@ /* Routines for handling XML generic OS data provided by target. - Copyright (C) 2008 Free Software Foundation, Inc. + Copyright (C) 2008-2021 Free Software Foundation, Inc. This file is part of GDB. @@ -19,16 +19,14 @@ #include "defs.h" #include "target.h" -#include "vec.h" #include "xml-support.h" #include "osdata.h" -#include "gdb_string.h" #include "ui-out.h" #include "gdbcmd.h" #if !defined(HAVE_LIBEXPAT) -struct osdata * +std::unique_ptr osdata_parse (const char *xml) { static int have_warned; @@ -37,7 +35,7 @@ osdata_parse (const char *xml) { have_warned = 1; warning (_("Can not parse XML OS data; XML support was disabled " - "at compile time")); + "at compile time")); } return NULL; @@ -45,108 +43,70 @@ osdata_parse (const char *xml) #else /* HAVE_LIBEXPAT */ -#include "xml-support.h" - /* Internal parsing data passed to all XML callbacks. */ struct osdata_parsing_data - { - struct osdata *osdata; - char *property_name; - }; - -static void -osdata_item_clear (struct osdata_item *item) { - if (item->columns != NULL) - { - struct osdata_column *col; - int ix; - for (ix = 0; - VEC_iterate (osdata_column_s, item->columns, - ix, col); - ix++) - { - xfree (col->name); - xfree (col->value); - } - VEC_free (osdata_column_s, item->columns); - item->columns = NULL; - } -} + std::unique_ptr osdata; + std::string property_name; +}; /* Handle the start of a element. */ static void osdata_start_osdata (struct gdb_xml_parser *parser, - const struct gdb_xml_element *element, - void *user_data, VEC(gdb_xml_value_s) *attributes) + const struct gdb_xml_element *element, + void *user_data, + std::vector &attributes) { - struct osdata_parsing_data *data = user_data; - char *type; - struct osdata *osdata; + struct osdata_parsing_data *data = (struct osdata_parsing_data *) user_data; - if (data->osdata) + if (data->osdata != NULL) gdb_xml_error (parser, _("Seen more than on osdata element")); - type = VEC_index (gdb_xml_value_s, attributes, 0)->value; - osdata = XZALLOC (struct osdata); - osdata->type = xstrdup (type); - data->osdata = osdata; + char *type = (char *) xml_find_attribute (attributes, "type")->value.get (); + data->osdata.reset (new struct osdata (std::string (type))); } /* Handle the start of a element. */ static void osdata_start_item (struct gdb_xml_parser *parser, - const struct gdb_xml_element *element, - void *user_data, VEC(gdb_xml_value_s) *attributes) + const struct gdb_xml_element *element, + void *user_data, + std::vector &attributes) { - struct osdata_parsing_data *data = user_data; - struct osdata_item item = { NULL }; - VEC_safe_push (osdata_item_s, data->osdata->items, &item); + struct osdata_parsing_data *data = (struct osdata_parsing_data *) user_data; + data->osdata->items.emplace_back (); } /* Handle the start of a element. */ static void osdata_start_column (struct gdb_xml_parser *parser, - const struct gdb_xml_element *element, - void *user_data, VEC(gdb_xml_value_s) *attributes) + const struct gdb_xml_element *element, + void *user_data, + std::vector &attributes) { - struct osdata_parsing_data *data = user_data; - const char *name = VEC_index (gdb_xml_value_s, attributes, 0)->value; - data->property_name = xstrdup (name); + struct osdata_parsing_data *data = (struct osdata_parsing_data *) user_data; + const char *name + = (const char *) xml_find_attribute (attributes, "name")->value.get (); + + data->property_name.assign (name); } /* Handle the end of a element. */ static void osdata_end_column (struct gdb_xml_parser *parser, - const struct gdb_xml_element *element, - void *user_data, const char *body_text) + const struct gdb_xml_element *element, + void *user_data, const char *body_text) { - struct osdata_parsing_data *data = user_data; - struct osdata *osdata = data->osdata; - struct osdata_item *item = VEC_last (osdata_item_s, osdata->items); - struct osdata_column *col = VEC_safe_push (osdata_column_s, - item->columns, NULL); - - /* Transfer memory ownership. NAME was already strdup'ed. */ - col->name = data->property_name; - col->value = xstrdup (body_text); - data->property_name = NULL; -} - -/* Discard the constructed osdata (if an error occurs). */ + osdata_parsing_data *data = (struct osdata_parsing_data *) user_data; + struct osdata *osdata = data->osdata.get (); + osdata_item &item = osdata->items.back (); -static void -clear_parsing_data (void *p) -{ - struct osdata_parsing_data *data = p; - osdata_free (data->osdata); - data->osdata = NULL; - xfree (data->property_name); - data->property_name = NULL; + item.columns.emplace_back (std::move (data->property_name), + std::string (body_text)); } /* The allowed elements and attributes for OS data object. @@ -182,176 +142,157 @@ const struct gdb_xml_element osdata_elements[] = { { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } }; -struct osdata * +std::unique_ptr osdata_parse (const char *xml) { - struct gdb_xml_parser *parser; - struct cleanup *before_deleting_result, *back_to; - struct osdata_parsing_data data = { NULL }; - - back_to = make_cleanup (null_cleanup, NULL); - parser = gdb_xml_create_parser_and_cleanup (_("osdata"), - osdata_elements, &data); - gdb_xml_use_dtd (parser, "osdata.dtd"); - - before_deleting_result = make_cleanup (clear_parsing_data, &data); - - if (gdb_xml_parse (parser, xml) == 0) - /* Parsed successfully, don't need to delete the result. */ - discard_cleanups (before_deleting_result); - - do_cleanups (back_to); - return data.osdata; -} -#endif - -void -osdata_free (struct osdata *osdata) -{ - if (osdata == NULL) - return; + osdata_parsing_data data; - if (osdata->items != NULL) + if (gdb_xml_parse_quick (_("osdata"), "osdata.dtd", + osdata_elements, xml, &data) == 0) { - struct osdata_item *item; - int ix; - for (ix = 0; - VEC_iterate (osdata_item_s, osdata->items, - ix, item); - ix++) - osdata_item_clear (item); - VEC_free (osdata_item_s, osdata->items); + /* Parsed successfully, don't need to delete the result. */ + return std::move (data.osdata); } - xfree (osdata); + return NULL; } +#endif -struct osdata *get_osdata (const char *type) +std::unique_ptr +get_osdata (const char *type) { - struct osdata * osdata = NULL; - char *xml = target_get_osdata (type); + std::unique_ptr osdata; + gdb::optional xml = target_get_osdata (type); + if (xml) { - if (xml[0] == '\0') - warning (_("Empty data returned by target. Wrong osdata type?")); - - osdata = osdata_parse (xml); + if ((*xml)[0] == '\0') + { + if (type) + warning (_("Empty data returned by target. Wrong osdata type?")); + else + warning (_("Empty type list returned by target. No type data?")); + } + else + osdata = osdata_parse (xml->data ()); } - - if (!osdata) - error (_("Can not fetch data now.\n")); + + if (osdata == NULL) + error (_("Can not fetch data now.")); return osdata; } -const char * -get_osdata_column (struct osdata_item *item, const char *name) +const std::string * +get_osdata_column (const osdata_item &item, const char *name) { - struct osdata_column *col; - int ix_cols; - - for (ix_cols = 0; - VEC_iterate (osdata_column_s, item->columns, - ix_cols, col); - ix_cols++) - if (strcmp (col->name, name) == 0) - return col->value; + for (const osdata_column &col : item.columns) + if (col.name == name) + return &col.value; return NULL; } void -info_osdata_command (char *type, int from_tty) +info_osdata (const char *type) { - struct osdata * osdata = NULL; - struct cleanup *proc_tbl_chain; - struct osdata_item *last; - int ncols; - int nprocs; + struct ui_out *uiout = current_uiout; + struct osdata_item *last = NULL; + int ncols = 0; + int col_to_skip = -1; - if (type == 0) - /* TODO: No type could mean "list availables types". */ - error (_("Argument required.")); + if (type == NULL) + type = ""; - osdata = get_osdata (type); + std::unique_ptr osdata = get_osdata (type); - nprocs = VEC_length (osdata_item_s, osdata->items); + int nrows = osdata->items.size (); - last = VEC_last (osdata_item_s, osdata->items); - if (last && last->columns) - ncols = VEC_length (osdata_column_s, last->columns); - else - ncols = 0; + if (*type == '\0' && nrows == 0) + error (_("Available types of OS data not reported.")); + + if (!osdata->items.empty ()) + { + last = &osdata->items.back (); + ncols = last->columns.size (); + + /* As a special case, scan the listing of available data types + for a column named "Title", and only include it with MI + output; this column's normal use is for titles for interface + elements like menus, and it clutters up CLI output. */ + if (*type == '\0' && !uiout->is_mi_like_p ()) + { + for (int ix = 0; ix < last->columns.size (); ix++) + { + if (last->columns[ix].name == "Title") + col_to_skip = ix; + } + /* Be sure to reduce the total column count, otherwise + internal errors ensue. */ + if (col_to_skip >= 0) + --ncols; + } + } - proc_tbl_chain - = make_cleanup_ui_out_table_begin_end (uiout, ncols, nprocs, - "OSDataTable"); + ui_out_emit_table table_emitter (uiout, ncols, nrows, "OSDataTable"); - if (last && last->columns) + /* With no columns/items, we just output an empty table, but we + still output the table. This matters for MI. */ + if (ncols == 0) + return; + + if (last != NULL && !last->columns.empty ()) { - struct osdata_column *col; - int ix; - for (ix = 0; - VEC_iterate (osdata_column_s, last->columns, - ix, col); - ix++) - ui_out_table_header (uiout, 10, ui_left, - col->name, col->name); + for (int ix = 0; ix < last->columns.size (); ix++) + { + char col_name[32]; + + if (ix == col_to_skip) + continue; + + snprintf (col_name, 32, "col%d", ix); + uiout->table_header (10, ui_left, + col_name, last->columns[ix].name.c_str ()); + } } - ui_out_table_body (uiout); + uiout->table_body (); - if (nprocs != 0) + if (nrows != 0) { - struct osdata_item *item; - int ix_items; - for (ix_items = 0; - VEC_iterate (osdata_item_s, osdata->items, - ix_items, item); - ix_items++) + for (const osdata_item &item : osdata->items) { - struct cleanup *old_chain, *chain; - struct ui_stream *stb; - int ix_cols; - struct osdata_column *col; + { + ui_out_emit_tuple tuple_emitter (uiout, "item"); - stb = ui_out_stream_new (uiout); - old_chain = make_cleanup_ui_out_stream_delete (stb); - chain = make_cleanup_ui_out_tuple_begin_end (uiout, "item"); + for (int ix_cols = 0; ix_cols < item.columns.size (); ix_cols++) + { + char col_name[32]; - for (ix_cols = 0; - VEC_iterate (osdata_column_s, item->columns, - ix_cols, col); - ix_cols++) - ui_out_field_string (uiout, col->name, col->value); + if (ix_cols == col_to_skip) + continue; - do_cleanups (chain); - do_cleanups (old_chain); + snprintf (col_name, 32, "col%d", ix_cols); + uiout->field_string (col_name, + item.columns[ix_cols].value.c_str ()); + } + } - ui_out_text (uiout, "\n"); + uiout->text ("\n"); } } - - do_cleanups (proc_tbl_chain); - - osdata_free (osdata); } static void -info_processes_command (char *args, int from_tty) +info_osdata_command (const char *arg, int from_tty) { - info_osdata_command ("processes", from_tty); + info_osdata (arg); } -extern initialize_file_ftype _initialize_osdata; /* -Wmissing-prototypes */ - +void _initialize_osdata (); void -_initialize_osdata (void) +_initialize_osdata () { add_info ("os", info_osdata_command, - _("Show OS data ARG.")); - - /* An alias for "info osdata processes". */ - add_info ("processes", info_processes_command, - _("List running processes on the target.")); + _("Show OS data ARG.")); }