gdb/xml-support.h

   1 /* Helper routines for parsing XML using Expat.
   2
   3    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21
  22 #ifndef XML_SUPPORT_H
  23 #define XML_SUPPORT_H
  24
  25 #include "gdb_obstack.h"
  26 #include "vec.h"
  27
  28 struct gdb_xml_parser;
  29 struct gdb_xml_element;
  30 struct gdb_xml_attribute;
  31
  32 /* Return an XML document which was compiled into GDB, from
  33    the given FILENAME, or NULL if the file was not compiled in.  */
  34
  35 const char *fetch_xml_builtin (const char *filename);
  36
  37 /* A to_xfer_partial helper function which reads XML files which were
  38    compiled into GDB.  The target may call this function from its own
  39    to_xfer_partial handler, after converting object and annex to the
  40    appropriate filename.  */
  41
  42 LONGEST xml_builtin_xfer_partial (const char *filename,
  43                                   gdb_byte *readbuf, const gdb_byte *writebuf,
  44                                   ULONGEST offset, LONGEST len);
  45
  46 /* The text of compiled-in XML documents, from xml-builtin.c
  47    (generated).  */
  48
  49 extern const char *xml_builtin[][2];
  50
  51 /* Return a malloc allocated string with special characters from TEXT
  52    replaced by entity references.  */
  53
  54 char *xml_escape_text (const char *text);
  55
  56 /* Support for XInclude.  */
  57
  58 /* Callback to fetch a new XML file, based on the provided HREF.  */
  59
  60 typedef char *(*xml_fetch_another) (const char *href, void *baton);
  61
  62 /* Return a new string which is the expansion of TEXT after processing
  63    <xi:include> tags.  FETCHER will be called (with FETCHER_BATON) to
  64    retrieve any new files.  DEPTH should be zero on the initial call.
  65
  66    On failure, this function uses NAME in a warning and returns NULL.
  67    It may throw an exception, but does not for XML parsing
  68    problems.  */
  69
  70 char *xml_process_xincludes (const char *name, const char *text,
  71                              xml_fetch_another fetcher, void *fetcher_baton,
  72                              int depth);
  73
  74 /* Simplified XML parser infrastructure.  */
  75
  76 /* A name and value pair, used to record parsed attributes.  */
  77
  78 struct gdb_xml_value
  79 {
  80   const char *name;
  81   void *value;
  82 };
  83 typedef struct gdb_xml_value gdb_xml_value_s;
  84 DEF_VEC_O(gdb_xml_value_s);
  85
  86 /* The type of an attribute handler.
  87
  88    PARSER is the current XML parser, which should be used to issue any
  89    debugging or error messages.  The second argument is the
  90    corresponding attribute description, so that a single handler can
  91    be used for multiple attributes; the attribute name is available
  92    for error messages and the handler data is available for additional
  93    customization (see gdb_xml_parse_attr_enum).  VALUE is the string
  94    value of the attribute.
  95
  96    The returned value should be freeable with xfree, and will be freed
  97    after the start handler is called.  Errors should be reported by
  98    calling gdb_xml_error.  */
  99
 100 typedef void *(gdb_xml_attribute_handler) (struct gdb_xml_parser *parser,
 101                                            const struct gdb_xml_attribute *,
 102                                            const char *value);
 103
 104 /* Flags for attributes.  If no flags are specified, the attribute is
 105    required.  */
 106
 107 enum gdb_xml_attribute_flag
 108 {
 109   GDB_XML_AF_NONE,
 110   GDB_XML_AF_OPTIONAL = 1 << 0,  /* The attribute is optional.  */
 111 };
 112
 113 /* An expected attribute and the handler to call when it is
 114    encountered.  Arrays of struct gdb_xml_attribute are terminated
 115    by an entry with NAME == NULL.  */
 116
 117 struct gdb_xml_attribute
 118 {
 119   const char *name;
 120   int flags;
 121   gdb_xml_attribute_handler *handler;
 122   const void *handler_data;
 123 };
 124
 125 /* Flags for elements.  If no flags are specified, the element is
 126    required exactly once.  */
 127
 128 enum gdb_xml_element_flag
 129 {
 130   GDB_XML_EF_NONE,
 131   GDB_XML_EF_OPTIONAL = 1 << 0,  /* The element is optional.  */
 132   GDB_XML_EF_REPEATABLE = 1 << 1,  /* The element is repeatable.  */
 133 };
 134
 135 /* A handler called at the beginning of an element.
 136
 137    PARSER is the current XML parser, which should be used to issue any
 138    debugging or error messages.  ELEMENT is the current element.
 139    USER_DATA is the opaque pointer supplied when the parser was
 140    created.  ATTRIBUTES is a vector of the values of any attributes
 141    attached to this element.
 142
 143    The start handler will only be called if all the required
 144    attributes were present and parsed successfully, and elements of
 145    ATTRIBUTES are guaranteed to be in the same order used in
 146    ELEMENT->ATTRIBUTES (not the order from the XML file).  Accordingly
 147    fixed offsets can be used to find any non-optional attributes as
 148    long as no optional attributes precede them.  */
 149
 150 typedef void (gdb_xml_element_start_handler)
 151      (struct gdb_xml_parser *parser, const struct gdb_xml_element *element,
 152       void *user_data, VEC(gdb_xml_value_s) *attributes);
 153
 154 /* A handler called at the end of an element.
 155
 156    PARSER, ELEMENT, and USER_DATA are as for the start handler.  BODY
 157    is any accumulated body text inside the element, with leading and
 158    trailing whitespace removed.  It will never be NULL.  */
 159
 160 typedef void (gdb_xml_element_end_handler)
 161      (struct gdb_xml_parser *, const struct gdb_xml_element *,
 162       void *user_data, const char *body_text);
 163
 164 /* An expected element and the handlers to call when it is
 165    encountered.  Arrays of struct gdb_xml_element are terminated
 166    by an entry with NAME == NULL.  */
 167
 168 struct gdb_xml_element
 169 {
 170   const char *name;
 171   const struct gdb_xml_attribute *attributes;
 172   const struct gdb_xml_element *children;
 173   int flags;
 174
 175   gdb_xml_element_start_handler *start_handler;
 176   gdb_xml_element_end_handler *end_handler;
 177 };
 178
 179 /* Initialize and return a parser.  Register a cleanup to destroy the
 180    parser.  */
 181
 182 struct gdb_xml_parser *gdb_xml_create_parser_and_cleanup
 183   (const char *name, const struct gdb_xml_element *elements,
 184    void *user_data);
 185
 186 /* Associate DTD_NAME, which must be the name of a compiled-in DTD,
 187    with PARSER.  */
 188
 189 void gdb_xml_use_dtd (struct gdb_xml_parser *parser, const char *dtd_name);
 190
 191 /* Invoke PARSER on BUFFER.  BUFFER is the data to parse, which
 192    should be NUL-terminated.
 193
 194    The return value is 0 for success or -1 for error.  It may throw,
 195    but only if something unexpected goes wrong during parsing; parse
 196    errors will be caught, warned about, and reported as failure.  */
 197
 198 int gdb_xml_parse (struct gdb_xml_parser *parser, const char *buffer);
 199
 200 /* Parse a XML document.  DOCUMENT is the data to parse, which should
 201    be NUL-terminated. If non-NULL, use the compiled-in DTD named
 202    DTD_NAME to drive the parsing.
 203
 204    The return value is 0 for success or -1 for error.  It may throw,
 205    but only if something unexpected goes wrong during parsing; parse
 206    errors will be caught, warned about, and reported as failure.  */
 207
 208 int gdb_xml_parse_quick (const char *name, const char *dtd_name,
 209                          const struct gdb_xml_element *elements,
 210                          const char *document, void *user_data);
 211
 212 /* Issue a debugging message from one of PARSER's handlers.  */
 213
 214 void gdb_xml_debug (struct gdb_xml_parser *parser, const char *format, ...)
 215      ATTRIBUTE_PRINTF (2, 0);
 216
 217 /* Issue an error message from one of PARSER's handlers, and stop
 218    parsing.  */
 219
 220 void gdb_xml_error (struct gdb_xml_parser *parser, const char *format, ...)
 221      ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 0);
 222
 223 /* Find the attribute named NAME in the set of parsed attributes
 224    ATTRIBUTES.  Returns NULL if not found.  */
 225
 226 struct gdb_xml_value *xml_find_attribute (VEC(gdb_xml_value_s) *attributes,
 227                                           const char *name);
 228
 229 /* Parse an integer attribute into a ULONGEST.  */
 230
 231 extern gdb_xml_attribute_handler gdb_xml_parse_attr_ulongest;
 232
 233 /* Map NAME to VALUE.  A struct gdb_xml_enum * should be saved as the
 234    value of handler_data when using gdb_xml_parse_attr_enum to parse a
 235    fixed list of possible strings.  The list is terminated by an entry
 236    with NAME == NULL.  */
 237
 238 struct gdb_xml_enum
 239 {
 240   const char *name;
 241   ULONGEST value;
 242 };
 243
 244 /* A handler_data for yes/no boolean values.  */
 245 extern const struct gdb_xml_enum gdb_xml_enums_boolean[];
 246
 247 extern gdb_xml_attribute_handler gdb_xml_parse_attr_enum;
 248
 249 /* Parse an integer string into a ULONGEST and return it, or call
 250    gdb_xml_error if it could not be parsed.  */
 251
 252 ULONGEST gdb_xml_parse_ulongest (struct gdb_xml_parser *parser,
 253                                  const char *value);
 254
 255 /* Simple printf to obstack function.  Current implemented formatters:
 256    %s - grow an xml escaped text in OBSTACK.  */
 257
 258 extern void obstack_xml_printf (struct obstack *obstack,
 259                                const char *format, ...)
 260   ATTRIBUTE_PRINTF_2;
 261
 262 /* Open FILENAME, read all its text into memory, close it, and return
 263    the text.  If something goes wrong, return NULL and warn.  */
 264
 265 extern char *xml_fetch_content_from_file (const char *filename,
 266                                           void *baton);
 267
 268 #endif