/* Routines for handling XML generic OS data provided by target. Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #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 * osdata_parse (const char *xml) { static int have_warned; if (!have_warned) { have_warned = 1; warning (_("Can not parse XML OS data; XML support was disabled " "at compile time")); } return NULL; } #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; }; /* Handle the start of a <osdata> 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) { struct osdata_parsing_data *data = user_data; char *type; struct osdata *osdata; if (data->osdata) 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; } /* Handle the start of a <item> 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) { struct osdata_parsing_data *data = user_data; struct osdata_item item = { NULL }; VEC_safe_push (osdata_item_s, data->osdata->items, &item); } /* Handle the start of a <column> 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) { struct osdata_parsing_data *data = user_data; const char *name = VEC_index (gdb_xml_value_s, attributes, 0)->value; data->property_name = xstrdup (name); } /* Handle the end of a <column> element. */ static void osdata_end_column (struct gdb_xml_parser *parser, 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). */ 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; } /* The allowed elements and attributes for OS data object. The root element is a <osdata>. */ const struct gdb_xml_attribute column_attributes[] = { { "name", GDB_XML_AF_NONE, NULL, NULL }, { NULL, GDB_XML_AF_NONE, NULL, NULL } }; const struct gdb_xml_element item_children[] = { { "column", column_attributes, NULL, GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, osdata_start_column, osdata_end_column }, { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } }; const struct gdb_xml_attribute osdata_attributes[] = { { "type", GDB_XML_AF_NONE, NULL, NULL }, { NULL, GDB_XML_AF_NONE, NULL, NULL } }; const struct gdb_xml_element osdata_children[] = { { "item", NULL, item_children, GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, osdata_start_item, NULL }, { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } }; const struct gdb_xml_element osdata_elements[] = { { "osdata", osdata_attributes, osdata_children, GDB_XML_EF_NONE, osdata_start_osdata, NULL }, { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } }; struct osdata * 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 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; } } void osdata_free (struct osdata *osdata) { if (osdata == NULL) return; if (osdata->items != NULL) { 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); } xfree (osdata); } static void osdata_free_cleanup (void *arg) { struct osdata *osdata = arg; osdata_free (osdata); } struct cleanup * make_cleanup_osdata_free (struct osdata *data) { return make_cleanup (osdata_free_cleanup, data); } struct osdata * get_osdata (const char *type) { struct osdata *osdata = NULL; char *xml = target_get_osdata (type); if (xml) { struct cleanup *old_chain = make_cleanup (xfree, 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); do_cleanups (old_chain); } if (!osdata) error (_("Can not fetch data now.\n")); return osdata; } const char * get_osdata_column (struct 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; return NULL; } static void info_osdata_command (char *type, int from_tty) { struct osdata *osdata = NULL; struct osdata_item *last; struct cleanup *old_chain; int ncols; int nprocs; osdata = get_osdata (type); old_chain = make_cleanup_osdata_free (osdata); nprocs = VEC_length (osdata_item_s, osdata->items); if (!type && nprocs == 0) error (_("Available types of OS data not reported.")); last = VEC_last (osdata_item_s, osdata->items); if (last && last->columns) ncols = VEC_length (osdata_column_s, last->columns); else ncols = 0; make_cleanup_ui_out_table_begin_end (uiout, ncols, nprocs, "OSDataTable"); if (last && last->columns) { 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); } ui_out_table_body (uiout); if (nprocs != 0) { struct osdata_item *item; int ix_items; for (ix_items = 0; VEC_iterate (osdata_item_s, osdata->items, ix_items, item); ix_items++) { struct cleanup *old_chain; struct ui_stream *stb; int ix_cols; struct osdata_column *col; stb = ui_out_stream_new (uiout); old_chain = make_cleanup_ui_out_stream_delete (stb); make_cleanup_ui_out_tuple_begin_end (uiout, "item"); 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); do_cleanups (old_chain); ui_out_text (uiout, "\n"); } } do_cleanups (old_chain); } extern initialize_file_ftype _initialize_osdata; /* -Wmissing-prototypes */ void _initialize_osdata (void) { add_info ("os", info_osdata_command, _("Show OS data ARG.")); }