/* Helper routines for parsing XML using Expat.
- Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2006-2016 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "gdbcmd.h"
-#include "exceptions.h"
#include "xml-support.h"
-
-#include "gdb_string.h"
+#include "filestuff.h"
#include "safe-ctype.h"
/* Debugging flag. */
static void
gdb_xml_body_text (void *data, const XML_Char *text, int length)
{
- struct gdb_xml_parser *parser = data;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data;
struct scope_level *scope = VEC_last (scope_level_s, parser->scopes);
if (parser->error.reason < 0)
if (scope->body == NULL)
{
- scope->body = XZALLOC (struct obstack);
+ scope->body = XCNEW (struct obstack);
obstack_init (scope->body);
}
throw_verror (XML_PARSE_ERROR, format, ap);
}
+/* Find the attribute named NAME in the set of parsed attributes
+ ATTRIBUTES. Returns NULL if not found. */
+
+struct gdb_xml_value *
+xml_find_attribute (VEC(gdb_xml_value_s) *attributes, const char *name)
+{
+ struct gdb_xml_value *value;
+ int ix;
+
+ for (ix = 0; VEC_iterate (gdb_xml_value_s, attributes, ix, value); ix++)
+ if (strcmp (value->name, name) == 0)
+ return value;
+
+ return NULL;
+}
+
/* Clean up a vector of parsed attribute values. */
static void
gdb_xml_values_cleanup (void *data)
{
- VEC(gdb_xml_value_s) **values = data;
+ VEC(gdb_xml_value_s) **values = (VEC(gdb_xml_value_s) **) data;
struct gdb_xml_value *value;
int ix;
gdb_xml_start_element (void *data, const XML_Char *name,
const XML_Char **attrs)
{
- struct gdb_xml_parser *parser = data;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data;
struct scope_level *scope;
struct scope_level new_scope;
const struct gdb_xml_element *element;
gdb_xml_start_element_wrapper (void *data, const XML_Char *name,
const XML_Char **attrs)
{
- struct gdb_xml_parser *parser = data;
- volatile struct gdb_exception ex;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data;
if (parser->error.reason < 0)
return;
- TRY_CATCH (ex, RETURN_MASK_ALL)
+ TRY
{
gdb_xml_start_element (data, name, attrs);
}
- if (ex.reason < 0)
+ CATCH (ex, RETURN_MASK_ALL)
{
parser->error = ex;
#ifdef HAVE_XML_STOPPARSER
XML_StopParser (parser->expat_parser, XML_FALSE);
#endif
}
+ END_CATCH
}
/* Handle the end of an element. DATA is our local XML parser, and
static void
gdb_xml_end_element (void *data, const XML_Char *name)
{
- struct gdb_xml_parser *parser = data;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data;
struct scope_level *scope = VEC_last (scope_level_s, parser->scopes);
const struct gdb_xml_element *element;
unsigned int seen;
gdb_xml_error (parser, _("Required element <%s> is missing"),
element->name);
- /* Call the element processor. */
+ /* Call the element processor. */
if (scope->element != NULL && scope->element->end_handler)
{
char *body;
length = obstack_object_size (scope->body);
obstack_1grow (scope->body, '\0');
- body = obstack_finish (scope->body);
+ body = (char *) obstack_finish (scope->body);
/* Strip leading and trailing whitespace. */
while (length > 0 && ISSPACE (body[length-1]))
static void
gdb_xml_end_element_wrapper (void *data, const XML_Char *name)
{
- struct gdb_xml_parser *parser = data;
- volatile struct gdb_exception ex;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data;
if (parser->error.reason < 0)
return;
- TRY_CATCH (ex, RETURN_MASK_ALL)
+ TRY
{
gdb_xml_end_element (data, name);
}
- if (ex.reason < 0)
+ CATCH (ex, RETURN_MASK_ALL)
{
parser->error = ex;
#ifdef HAVE_XML_STOPPARSER
XML_StopParser (parser->expat_parser, XML_FALSE);
#endif
}
+ END_CATCH
}
/* Free a parser and all its associated state. */
static void
gdb_xml_cleanup (void *arg)
{
- struct gdb_xml_parser *parser = arg;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) arg;
struct scope_level *scope;
int ix;
xfree (parser);
}
-/* Initialize and return a parser. Register a cleanup to destroy the
- parser. */
+/* Initialize a parser and store it to *PARSER_RESULT. Register a
+ cleanup to destroy the parser. */
-struct gdb_xml_parser *
+static struct cleanup *
gdb_xml_create_parser_and_cleanup (const char *name,
const struct gdb_xml_element *elements,
- void *user_data)
+ void *user_data,
+ struct gdb_xml_parser **parser_result)
{
struct gdb_xml_parser *parser;
struct scope_level start_scope;
+ struct cleanup *result;
/* Initialize the parser. */
- parser = XZALLOC (struct gdb_xml_parser);
+ parser = XCNEW (struct gdb_xml_parser);
parser->expat_parser = XML_ParserCreateNS (NULL, '!');
if (parser->expat_parser == NULL)
{
xfree (parser);
- nomem (0);
+ malloc_failure (0);
}
parser->name = name;
start_scope.elements = elements;
VEC_safe_push (scope_level_s, parser->scopes, &start_scope);
- make_cleanup (gdb_xml_cleanup, parser);
-
- return parser;
+ *parser_result = parser;
+ return make_cleanup (gdb_xml_cleanup, parser);
}
/* External entity handler. The only external entities we support
const XML_Char *systemId,
const XML_Char *publicId)
{
- struct gdb_xml_parser *parser = XML_GetUserData (expat_parser);
+ struct gdb_xml_parser *parser
+ = (struct gdb_xml_parser *) XML_GetUserData (expat_parser);
XML_Parser entity_parser;
const char *text;
enum XML_Status status;
{
text = fetch_xml_builtin (parser->dtd_name);
if (text == NULL)
- internal_error (__FILE__, __LINE__, "could not locate built-in DTD %s",
+ internal_error (__FILE__, __LINE__,
+ _("could not locate built-in DTD %s"),
parser->dtd_name);
}
else
err = XML_UseForeignDTD (parser->expat_parser, XML_TRUE);
if (err != XML_ERROR_NONE)
internal_error (__FILE__, __LINE__,
- "XML_UseForeignDTD failed: %s", XML_ErrorString (err));
+ _("XML_UseForeignDTD failed: %s"),
+ XML_ErrorString (err));
}
/* Invoke PARSER on BUFFER. BUFFER is the data to parse, which
return -1;
}
+int
+gdb_xml_parse_quick (const char *name, const char *dtd_name,
+ const struct gdb_xml_element *elements,
+ const char *document, void *user_data)
+{
+ struct gdb_xml_parser *parser;
+ struct cleanup *back_to;
+ int result;
+
+ back_to = gdb_xml_create_parser_and_cleanup (name, elements,
+ user_data, &parser);
+ if (dtd_name != NULL)
+ gdb_xml_use_dtd (parser, dtd_name);
+ result = gdb_xml_parse (parser, document);
+
+ do_cleanups (back_to);
+
+ return result;
+}
+
/* Parse a field VALSTR that we expect to contain an integer value.
The integer is returned in *VALP. The string is parsed with an
equivalent to strtoul.
gdb_xml_error (parser, _("Can't convert %s=\"%s\" to an integer"),
attribute->name, value);
- ret = xmalloc (sizeof (result));
+ ret = XNEW (ULONGEST);
memcpy (ret, &result, sizeof (result));
return ret;
}
const struct gdb_xml_attribute *attribute,
const char *value)
{
- const struct gdb_xml_enum *enums = attribute->handler_data;
+ const struct gdb_xml_enum *enums
+ = (const struct gdb_xml_enum *) attribute->handler_data;
void *ret;
- for (enums = attribute->handler_data; enums->name != NULL; enums++)
+ for (enums = (const struct gdb_xml_enum *) attribute->handler_data;
+ enums->name != NULL; enums++)
if (strcasecmp (enums->name, value) == 0)
break;
const struct gdb_xml_element *element,
void *user_data, VEC(gdb_xml_value_s) *attributes)
{
- struct xinclude_parsing_data *data = user_data;
- char *href = VEC_index (gdb_xml_value_s, attributes, 0)->value;
+ struct xinclude_parsing_data *data
+ = (struct xinclude_parsing_data *) user_data;
+ char *href = (char *) xml_find_attribute (attributes, "href")->value;
struct cleanup *back_to;
char *text, *output;
const struct gdb_xml_element *element,
void *user_data, const char *body_text)
{
- struct xinclude_parsing_data *data = user_data;
+ struct xinclude_parsing_data *data
+ = (struct xinclude_parsing_data *) user_data;
data->skip_depth--;
}
static void XMLCALL
xml_xinclude_default (void *data_, const XML_Char *s, int len)
{
- struct gdb_xml_parser *parser = data_;
- struct xinclude_parsing_data *data = parser->user_data;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data_;
+ struct xinclude_parsing_data *data
+ = (struct xinclude_parsing_data *) parser->user_data;
/* If we are inside of e.g. xi:include or the DTD, don't save this
string. */
const XML_Char *sysid, const XML_Char *pubid,
int has_internal_subset)
{
- struct gdb_xml_parser *parser = data_;
- struct xinclude_parsing_data *data = parser->user_data;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data_;
+ struct xinclude_parsing_data *data
+ = (struct xinclude_parsing_data *) parser->user_data;
/* Don't print out the doctype, or the contents of the DTD internal
subset, if any. */
static void XMLCALL
xml_xinclude_end_doctype (void *data_)
{
- struct gdb_xml_parser *parser = data_;
- struct xinclude_parsing_data *data = parser->user_data;
+ struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data_;
+ struct xinclude_parsing_data *data
+ = (struct xinclude_parsing_data *) parser->user_data;
data->skip_depth--;
}
static void
xml_xinclude_cleanup (void *data_)
{
- struct xinclude_parsing_data *data = data_;
+ struct xinclude_parsing_data *data = (struct xinclude_parsing_data *) data_;
obstack_free (&data->obstack, NULL);
xfree (data);
struct cleanup *back_to;
char *result = NULL;
- data = XZALLOC (struct xinclude_parsing_data);
+ data = XCNEW (struct xinclude_parsing_data);
obstack_init (&data->obstack);
back_to = make_cleanup (xml_xinclude_cleanup, data);
- parser = gdb_xml_create_parser_and_cleanup (name, xinclude_elements, data);
+ gdb_xml_create_parser_and_cleanup (name, xinclude_elements,
+ data, &parser);
parser->is_xinclude = 1;
data->include_depth = depth;
if (gdb_xml_parse (parser, text) == 0)
{
obstack_1grow (&data->obstack, '\0');
- result = xstrdup (obstack_finish (&data->obstack));
+ result = xstrdup ((const char *) obstack_finish (&data->obstack));
if (depth == 0)
gdb_xml_debug (parser, _("XInclude processing succeeded."));
fprintf_filtered (file, _("XML debugging is %s.\n"), value);
}
-/* Return a malloc allocated string with special characters from TEXT
- replaced by entity references. */
-
-char *
-xml_escape_text (const char *text)
-{
- char *result;
- int i, special;
-
- /* Compute the length of the result. */
- for (i = 0, special = 0; text[i] != '\0'; i++)
- switch (text[i])
- {
- case '\'':
- case '\"':
- special += 5;
- break;
- case '&':
- special += 4;
- break;
- case '<':
- case '>':
- special += 3;
- break;
- default:
- break;
- }
-
- /* Expand the result. */
- result = xmalloc (i + special + 1);
- for (i = 0, special = 0; text[i] != '\0'; i++)
- switch (text[i])
- {
- case '\'':
- strcpy (result + i + special, "'");
- special += 5;
- break;
- case '\"':
- strcpy (result + i + special, """);
- special += 5;
- break;
- case '&':
- strcpy (result + i + special, "&");
- special += 4;
- break;
- case '<':
- strcpy (result + i + special, "<");
- special += 3;
- break;
- case '>':
- strcpy (result + i + special, ">");
- special += 3;
- break;
- default:
- result[i + special] = text[i];
- break;
- }
- result[i + special] = '\0';
-
- return result;
-}
-
void
obstack_xml_printf (struct obstack *obstack, const char *format, ...)
{
char *
xml_fetch_content_from_file (const char *filename, void *baton)
{
- const char *dirname = baton;
+ const char *dirname = (const char *) baton;
FILE *file;
struct cleanup *back_to;
char *text;
char *fullname = concat (dirname, "/", filename, (char *) NULL);
if (fullname == NULL)
- nomem (0);
- file = fopen (fullname, FOPEN_RT);
+ malloc_failure (0);
+ file = gdb_fopen_cloexec (fullname, FOPEN_RT);
xfree (fullname);
}
else
- file = fopen (filename, FOPEN_RT);
+ file = gdb_fopen_cloexec (filename, FOPEN_RT);
if (file == NULL)
return NULL;
/* Read in the whole file, one chunk at a time. */
len = 4096;
offset = 0;
- text = xmalloc (len);
+ text = (char *) xmalloc (len);
make_cleanup (free_current_contents, &text);
while (1)
{
break;
len = len * 2;
- text = xrealloc (text, len);
+ text = (char *) xrealloc (text, len);
}
fclose (file);