1 /* Helper routines for parsing XML using Expat.
3 Copyright (C) 2006-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "xml-support.h"
23 #include "filestuff.h"
24 #include "safe-ctype.h"
29 /* The contents of this file are only useful if XML support is
33 #include "gdb_expat.h"
35 /* The maximum depth of <xi:include> nesting. No need to be miserly,
36 we just want to avoid running out of stack on loops. */
37 #define MAX_XINCLUDE_DEPTH 30
39 /* Simplified XML parser infrastructure. */
41 /* A parsing level -- used to keep track of the current element
45 /* Elements we allow at this level. */
46 const struct gdb_xml_element
*elements
;
48 /* The element which we are within. */
49 const struct gdb_xml_element
*element
;
51 /* Mask of which elements we've seen at this level (used for
52 optional and repeatable checking). */
55 /* Body text accumulation. */
58 typedef struct scope_level scope_level_s
;
59 DEF_VEC_O(scope_level_s
);
61 /* The parser itself, and our additional state. */
64 XML_Parser expat_parser
; /* The underlying expat parser. */
66 const char *name
; /* Name of this parser. */
67 void *user_data
; /* The user's callback data, for handlers. */
69 VEC(scope_level_s
) *scopes
; /* Scoping stack. */
71 struct gdb_exception error
; /* A thrown error, if any. */
72 int last_line
; /* The line of the thrown error, or 0. */
74 const char *dtd_name
; /* The name of the expected / default DTD,
76 int is_xinclude
; /* Are we the special <xi:include> parser? */
79 /* Process some body text. We accumulate the text for later use; it's
80 wrong to do anything with it immediately, because a single block of
81 text might be broken up into multiple calls to this function. */
84 gdb_xml_body_text (void *data
, const XML_Char
*text
, int length
)
86 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
87 struct scope_level
*scope
= VEC_last (scope_level_s
, parser
->scopes
);
89 if (parser
->error
.reason
< 0)
92 if (scope
->body
== NULL
)
94 scope
->body
= XCNEW (struct obstack
);
95 obstack_init (scope
->body
);
98 obstack_grow (scope
->body
, text
, length
);
101 /* Issue a debugging message from one of PARSER's handlers. */
104 gdb_xml_debug (struct gdb_xml_parser
*parser
, const char *format
, ...)
106 int line
= XML_GetCurrentLineNumber (parser
->expat_parser
);
113 va_start (ap
, format
);
114 message
= xstrvprintf (format
, ap
);
116 fprintf_unfiltered (gdb_stderr
, "%s (line %d): %s\n",
117 parser
->name
, line
, message
);
119 fprintf_unfiltered (gdb_stderr
, "%s: %s\n",
120 parser
->name
, message
);
124 /* Issue an error message from one of PARSER's handlers, and stop
128 gdb_xml_error (struct gdb_xml_parser
*parser
, const char *format
, ...)
130 int line
= XML_GetCurrentLineNumber (parser
->expat_parser
);
133 parser
->last_line
= line
;
134 va_start (ap
, format
);
135 throw_verror (XML_PARSE_ERROR
, format
, ap
);
138 /* Find the attribute named NAME in the set of parsed attributes
139 ATTRIBUTES. Returns NULL if not found. */
141 struct gdb_xml_value
*
142 xml_find_attribute (VEC(gdb_xml_value_s
) *attributes
, const char *name
)
144 struct gdb_xml_value
*value
;
147 for (ix
= 0; VEC_iterate (gdb_xml_value_s
, attributes
, ix
, value
); ix
++)
148 if (strcmp (value
->name
, name
) == 0)
154 /* Clean up a vector of parsed attribute values. */
157 gdb_xml_values_cleanup (void *data
)
159 VEC(gdb_xml_value_s
) **values
= (VEC(gdb_xml_value_s
) **) data
;
160 struct gdb_xml_value
*value
;
163 for (ix
= 0; VEC_iterate (gdb_xml_value_s
, *values
, ix
, value
); ix
++)
164 xfree (value
->value
);
165 VEC_free (gdb_xml_value_s
, *values
);
168 /* Handle the start of an element. DATA is our local XML parser, NAME
169 is the element, and ATTRS are the names and values of this
170 element's attributes. */
173 gdb_xml_start_element (void *data
, const XML_Char
*name
,
174 const XML_Char
**attrs
)
176 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
177 struct scope_level
*scope
;
178 struct scope_level new_scope
;
179 const struct gdb_xml_element
*element
;
180 const struct gdb_xml_attribute
*attribute
;
181 VEC(gdb_xml_value_s
) *attributes
= NULL
;
183 struct cleanup
*back_to
;
185 /* Push an error scope. If we return or throw an exception before
186 filling this in, it will tell us to ignore children of this
188 VEC_reserve (scope_level_s
, parser
->scopes
, 1);
189 scope
= VEC_last (scope_level_s
, parser
->scopes
);
190 memset (&new_scope
, 0, sizeof (new_scope
));
191 VEC_quick_push (scope_level_s
, parser
->scopes
, &new_scope
);
193 gdb_xml_debug (parser
, _("Entering element <%s>"), name
);
195 /* Find this element in the list of the current scope's allowed
196 children. Record that we've seen it. */
199 for (element
= scope
->elements
; element
&& element
->name
;
200 element
++, seen
<<= 1)
201 if (strcmp (element
->name
, name
) == 0)
204 if (element
== NULL
|| element
->name
== NULL
)
206 /* If we're working on XInclude, <xi:include> can be the child
207 of absolutely anything. Copy the previous scope's element
208 list into the new scope even if there was no match. */
209 if (parser
->is_xinclude
)
211 struct scope_level
*unknown_scope
;
213 XML_DefaultCurrent (parser
->expat_parser
);
215 unknown_scope
= VEC_last (scope_level_s
, parser
->scopes
);
216 unknown_scope
->elements
= scope
->elements
;
220 gdb_xml_debug (parser
, _("Element <%s> unknown"), name
);
224 if (!(element
->flags
& GDB_XML_EF_REPEATABLE
) && (seen
& scope
->seen
))
225 gdb_xml_error (parser
, _("Element <%s> only expected once"), name
);
229 back_to
= make_cleanup (gdb_xml_values_cleanup
, &attributes
);
231 for (attribute
= element
->attributes
;
232 attribute
!= NULL
&& attribute
->name
!= NULL
;
235 const char *val
= NULL
;
238 struct gdb_xml_value new_value
;
240 for (p
= attrs
; *p
!= NULL
; p
+= 2)
241 if (!strcmp (attribute
->name
, p
[0]))
247 if (*p
!= NULL
&& val
== NULL
)
249 gdb_xml_debug (parser
, _("Attribute \"%s\" missing a value"),
254 if (*p
== NULL
&& !(attribute
->flags
& GDB_XML_AF_OPTIONAL
))
256 gdb_xml_error (parser
, _("Required attribute \"%s\" of "
257 "<%s> not specified"),
258 attribute
->name
, element
->name
);
265 gdb_xml_debug (parser
, _("Parsing attribute %s=\"%s\""),
266 attribute
->name
, val
);
268 if (attribute
->handler
)
269 parsed_value
= attribute
->handler (parser
, attribute
, val
);
271 parsed_value
= xstrdup (val
);
273 new_value
.name
= attribute
->name
;
274 new_value
.value
= parsed_value
;
275 VEC_safe_push (gdb_xml_value_s
, attributes
, &new_value
);
278 /* Check for unrecognized attributes. */
283 for (p
= attrs
; *p
!= NULL
; p
+= 2)
285 for (attribute
= element
->attributes
;
286 attribute
!= NULL
&& attribute
->name
!= NULL
;
288 if (strcmp (attribute
->name
, *p
) == 0)
291 if (attribute
== NULL
|| attribute
->name
== NULL
)
292 gdb_xml_debug (parser
, _("Ignoring unknown attribute %s"), *p
);
296 /* Call the element handler if there is one. */
297 if (element
->start_handler
)
298 element
->start_handler (parser
, element
, parser
->user_data
, attributes
);
300 /* Fill in a new scope level. */
301 scope
= VEC_last (scope_level_s
, parser
->scopes
);
302 scope
->element
= element
;
303 scope
->elements
= element
->children
;
305 do_cleanups (back_to
);
308 /* Wrapper for gdb_xml_start_element, to prevent throwing exceptions
312 gdb_xml_start_element_wrapper (void *data
, const XML_Char
*name
,
313 const XML_Char
**attrs
)
315 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
317 if (parser
->error
.reason
< 0)
322 gdb_xml_start_element (data
, name
, attrs
);
324 CATCH (ex
, RETURN_MASK_ALL
)
327 #ifdef HAVE_XML_STOPPARSER
328 XML_StopParser (parser
->expat_parser
, XML_FALSE
);
334 /* Handle the end of an element. DATA is our local XML parser, and
335 NAME is the current element. */
338 gdb_xml_end_element (void *data
, const XML_Char
*name
)
340 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
341 struct scope_level
*scope
= VEC_last (scope_level_s
, parser
->scopes
);
342 const struct gdb_xml_element
*element
;
345 gdb_xml_debug (parser
, _("Leaving element <%s>"), name
);
347 for (element
= scope
->elements
, seen
= 1;
348 element
!= NULL
&& element
->name
!= NULL
;
349 element
++, seen
<<= 1)
350 if ((scope
->seen
& seen
) == 0
351 && (element
->flags
& GDB_XML_EF_OPTIONAL
) == 0)
352 gdb_xml_error (parser
, _("Required element <%s> is missing"),
355 /* Call the element processor. */
356 if (scope
->element
!= NULL
&& scope
->element
->end_handler
)
358 const char *scope_body
;
360 if (scope
->body
== NULL
)
366 length
= obstack_object_size (scope
->body
);
367 obstack_1grow (scope
->body
, '\0');
368 char *body
= (char *) obstack_finish (scope
->body
);
370 /* Strip leading and trailing whitespace. */
371 while (length
> 0 && ISSPACE (body
[length
-1]))
372 body
[--length
] = '\0';
373 while (*body
&& ISSPACE (*body
))
379 scope
->element
->end_handler (parser
, scope
->element
, parser
->user_data
,
382 else if (scope
->element
== NULL
)
383 XML_DefaultCurrent (parser
->expat_parser
);
385 /* Pop the scope level. */
388 obstack_free (scope
->body
, NULL
);
391 VEC_pop (scope_level_s
, parser
->scopes
);
394 /* Wrapper for gdb_xml_end_element, to prevent throwing exceptions
398 gdb_xml_end_element_wrapper (void *data
, const XML_Char
*name
)
400 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
402 if (parser
->error
.reason
< 0)
407 gdb_xml_end_element (data
, name
);
409 CATCH (ex
, RETURN_MASK_ALL
)
412 #ifdef HAVE_XML_STOPPARSER
413 XML_StopParser (parser
->expat_parser
, XML_FALSE
);
419 /* Free a parser and all its associated state. */
422 gdb_xml_cleanup (void *arg
)
424 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) arg
;
425 struct scope_level
*scope
;
428 XML_ParserFree (parser
->expat_parser
);
430 /* Clean up the scopes. */
431 for (ix
= 0; VEC_iterate (scope_level_s
, parser
->scopes
, ix
, scope
); ix
++)
434 obstack_free (scope
->body
, NULL
);
437 VEC_free (scope_level_s
, parser
->scopes
);
442 /* Initialize a parser and store it to *PARSER_RESULT. Register a
443 cleanup to destroy the parser. */
445 static struct cleanup
*
446 gdb_xml_create_parser_and_cleanup (const char *name
,
447 const struct gdb_xml_element
*elements
,
449 struct gdb_xml_parser
**parser_result
)
451 struct gdb_xml_parser
*parser
;
452 struct scope_level start_scope
;
453 struct cleanup
*result
;
455 /* Initialize the parser. */
456 parser
= XCNEW (struct gdb_xml_parser
);
457 parser
->expat_parser
= XML_ParserCreateNS (NULL
, '!');
458 if (parser
->expat_parser
== NULL
)
466 parser
->user_data
= user_data
;
467 XML_SetUserData (parser
->expat_parser
, parser
);
469 /* Set the callbacks. */
470 XML_SetElementHandler (parser
->expat_parser
, gdb_xml_start_element_wrapper
,
471 gdb_xml_end_element_wrapper
);
472 XML_SetCharacterDataHandler (parser
->expat_parser
, gdb_xml_body_text
);
474 /* Initialize the outer scope. */
475 memset (&start_scope
, 0, sizeof (start_scope
));
476 start_scope
.elements
= elements
;
477 VEC_safe_push (scope_level_s
, parser
->scopes
, &start_scope
);
479 *parser_result
= parser
;
480 return make_cleanup (gdb_xml_cleanup
, parser
);
483 /* External entity handler. The only external entities we support
484 are those compiled into GDB (we do not fetch entities from the
488 gdb_xml_fetch_external_entity (XML_Parser expat_parser
,
489 const XML_Char
*context
,
490 const XML_Char
*base
,
491 const XML_Char
*systemId
,
492 const XML_Char
*publicId
)
494 struct gdb_xml_parser
*parser
495 = (struct gdb_xml_parser
*) XML_GetUserData (expat_parser
);
496 XML_Parser entity_parser
;
498 enum XML_Status status
;
500 if (systemId
== NULL
)
502 text
= fetch_xml_builtin (parser
->dtd_name
);
504 internal_error (__FILE__
, __LINE__
,
505 _("could not locate built-in DTD %s"),
510 text
= fetch_xml_builtin (systemId
);
512 return XML_STATUS_ERROR
;
515 entity_parser
= XML_ExternalEntityParserCreate (expat_parser
, context
, NULL
);
517 /* Don't use our handlers for the contents of the DTD. Just let expat
519 XML_SetElementHandler (entity_parser
, NULL
, NULL
);
520 XML_SetDoctypeDeclHandler (entity_parser
, NULL
, NULL
);
521 XML_SetXmlDeclHandler (entity_parser
, NULL
);
522 XML_SetDefaultHandler (entity_parser
, NULL
);
523 XML_SetUserData (entity_parser
, NULL
);
525 status
= XML_Parse (entity_parser
, text
, strlen (text
), 1);
527 XML_ParserFree (entity_parser
);
531 /* Associate DTD_NAME, which must be the name of a compiled-in DTD,
535 gdb_xml_use_dtd (struct gdb_xml_parser
*parser
, const char *dtd_name
)
539 parser
->dtd_name
= dtd_name
;
541 XML_SetParamEntityParsing (parser
->expat_parser
,
542 XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE
);
543 XML_SetExternalEntityRefHandler (parser
->expat_parser
,
544 gdb_xml_fetch_external_entity
);
546 /* Even if no DTD is provided, use the built-in DTD anyway. */
547 err
= XML_UseForeignDTD (parser
->expat_parser
, XML_TRUE
);
548 if (err
!= XML_ERROR_NONE
)
549 internal_error (__FILE__
, __LINE__
,
550 _("XML_UseForeignDTD failed: %s"),
551 XML_ErrorString (err
));
554 /* Invoke PARSER on BUFFER. BUFFER is the data to parse, which
555 should be NUL-terminated.
557 The return value is 0 for success or -1 for error. It may throw,
558 but only if something unexpected goes wrong during parsing; parse
559 errors will be caught, warned about, and reported as failure. */
562 gdb_xml_parse (struct gdb_xml_parser
*parser
, const char *buffer
)
564 enum XML_Status status
;
565 const char *error_string
;
567 gdb_xml_debug (parser
, _("Starting:\n%s"), buffer
);
569 status
= XML_Parse (parser
->expat_parser
, buffer
, strlen (buffer
), 1);
571 if (status
== XML_STATUS_OK
&& parser
->error
.reason
== 0)
574 if (parser
->error
.reason
== RETURN_ERROR
575 && parser
->error
.error
== XML_PARSE_ERROR
)
577 gdb_assert (parser
->error
.message
!= NULL
);
578 error_string
= parser
->error
.message
;
580 else if (status
== XML_STATUS_ERROR
)
582 enum XML_Error err
= XML_GetErrorCode (parser
->expat_parser
);
584 error_string
= XML_ErrorString (err
);
588 gdb_assert (parser
->error
.reason
< 0);
589 throw_exception (parser
->error
);
592 if (parser
->last_line
!= 0)
593 warning (_("while parsing %s (at line %d): %s"), parser
->name
,
594 parser
->last_line
, error_string
);
596 warning (_("while parsing %s: %s"), parser
->name
, error_string
);
602 gdb_xml_parse_quick (const char *name
, const char *dtd_name
,
603 const struct gdb_xml_element
*elements
,
604 const char *document
, void *user_data
)
606 struct gdb_xml_parser
*parser
;
607 struct cleanup
*back_to
;
610 back_to
= gdb_xml_create_parser_and_cleanup (name
, elements
,
612 if (dtd_name
!= NULL
)
613 gdb_xml_use_dtd (parser
, dtd_name
);
614 result
= gdb_xml_parse (parser
, document
);
616 do_cleanups (back_to
);
621 /* Parse a field VALSTR that we expect to contain an integer value.
622 The integer is returned in *VALP. The string is parsed with an
623 equivalent to strtoul.
625 Returns 0 for success, -1 for error. */
628 xml_parse_unsigned_integer (const char *valstr
, ULONGEST
*valp
)
636 result
= strtoulst (valstr
, &endptr
, 0);
644 /* Parse an integer string into a ULONGEST and return it, or call
645 gdb_xml_error if it could not be parsed. */
648 gdb_xml_parse_ulongest (struct gdb_xml_parser
*parser
, const char *value
)
652 if (xml_parse_unsigned_integer (value
, &result
) != 0)
653 gdb_xml_error (parser
, _("Can't convert \"%s\" to an integer"), value
);
658 /* Parse an integer attribute into a ULONGEST. */
661 gdb_xml_parse_attr_ulongest (struct gdb_xml_parser
*parser
,
662 const struct gdb_xml_attribute
*attribute
,
668 if (xml_parse_unsigned_integer (value
, &result
) != 0)
669 gdb_xml_error (parser
, _("Can't convert %s=\"%s\" to an integer"),
670 attribute
->name
, value
);
672 ret
= XNEW (ULONGEST
);
673 memcpy (ret
, &result
, sizeof (result
));
677 /* A handler_data for yes/no boolean values. */
679 const struct gdb_xml_enum gdb_xml_enums_boolean
[] = {
685 /* Map NAME to VALUE. A struct gdb_xml_enum * should be saved as the
686 value of handler_data when using gdb_xml_parse_attr_enum to parse a
687 fixed list of possible strings. The list is terminated by an entry
688 with NAME == NULL. */
691 gdb_xml_parse_attr_enum (struct gdb_xml_parser
*parser
,
692 const struct gdb_xml_attribute
*attribute
,
695 const struct gdb_xml_enum
*enums
696 = (const struct gdb_xml_enum
*) attribute
->handler_data
;
699 for (enums
= (const struct gdb_xml_enum
*) attribute
->handler_data
;
700 enums
->name
!= NULL
; enums
++)
701 if (strcasecmp (enums
->name
, value
) == 0)
704 if (enums
->name
== NULL
)
705 gdb_xml_error (parser
, _("Unknown attribute value %s=\"%s\""),
706 attribute
->name
, value
);
708 ret
= xmalloc (sizeof (enums
->value
));
709 memcpy (ret
, &enums
->value
, sizeof (enums
->value
));
714 /* XInclude processing. This is done as a separate step from actually
715 parsing the document, so that we can produce a single combined XML
716 document - e.g. to hand to a front end or to simplify comparing two
717 documents. We make extensive use of XML_DefaultCurrent, to pass
718 input text directly into the output without reformatting or
721 We output the DOCTYPE declaration for the first document unchanged,
722 if present, and discard DOCTYPEs from included documents. Only the
723 one we pass through here is used when we feed the result back to
724 expat. The XInclude standard explicitly does not discuss
725 validation of the result; we choose to apply the same DTD applied
726 to the outermost document.
728 We can not simply include the external DTD subset in the document
729 as an internal subset, because <!IGNORE> and <!INCLUDE> are valid
730 only in external subsets. But if we do not pass the DTD into the
731 output at all, default values will not be filled in.
733 We don't pass through any <?xml> declaration because we generate
734 UTF-8, not whatever the input encoding was. */
736 struct xinclude_parsing_data
738 /* The obstack to build the output in. */
739 struct obstack obstack
;
741 /* A count indicating whether we are in an element whose
742 children should not be copied to the output, and if so,
743 how deep we are nested. This is used for anything inside
744 an xi:include, and for the DTD. */
747 /* The number of <xi:include> elements currently being processed,
751 /* A function to call to obtain additional features, and its
753 xml_fetch_another fetcher
;
758 xinclude_start_include (struct gdb_xml_parser
*parser
,
759 const struct gdb_xml_element
*element
,
760 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
762 struct xinclude_parsing_data
*data
763 = (struct xinclude_parsing_data
*) user_data
;
764 char *href
= (char *) xml_find_attribute (attributes
, "href")->value
;
765 struct cleanup
*back_to
;
768 gdb_xml_debug (parser
, _("Processing XInclude of \"%s\""), href
);
770 if (data
->include_depth
> MAX_XINCLUDE_DEPTH
)
771 gdb_xml_error (parser
, _("Maximum XInclude depth (%d) exceeded"),
774 text
= data
->fetcher (href
, data
->fetcher_baton
);
776 gdb_xml_error (parser
, _("Could not load XML document \"%s\""), href
);
777 back_to
= make_cleanup (xfree
, text
);
779 output
= xml_process_xincludes (parser
->name
, text
, data
->fetcher
,
781 data
->include_depth
+ 1);
783 gdb_xml_error (parser
, _("Parsing \"%s\" failed"), href
);
785 obstack_grow (&data
->obstack
, output
, strlen (output
));
788 do_cleanups (back_to
);
794 xinclude_end_include (struct gdb_xml_parser
*parser
,
795 const struct gdb_xml_element
*element
,
796 void *user_data
, const char *body_text
)
798 struct xinclude_parsing_data
*data
799 = (struct xinclude_parsing_data
*) user_data
;
805 xml_xinclude_default (void *data_
, const XML_Char
*s
, int len
)
807 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data_
;
808 struct xinclude_parsing_data
*data
809 = (struct xinclude_parsing_data
*) parser
->user_data
;
811 /* If we are inside of e.g. xi:include or the DTD, don't save this
813 if (data
->skip_depth
)
816 /* Otherwise just add it to the end of the document we're building
818 obstack_grow (&data
->obstack
, s
, len
);
822 xml_xinclude_start_doctype (void *data_
, const XML_Char
*doctypeName
,
823 const XML_Char
*sysid
, const XML_Char
*pubid
,
824 int has_internal_subset
)
826 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data_
;
827 struct xinclude_parsing_data
*data
828 = (struct xinclude_parsing_data
*) parser
->user_data
;
830 /* Don't print out the doctype, or the contents of the DTD internal
836 xml_xinclude_end_doctype (void *data_
)
838 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data_
;
839 struct xinclude_parsing_data
*data
840 = (struct xinclude_parsing_data
*) parser
->user_data
;
846 xml_xinclude_xml_decl (void *data_
, const XML_Char
*version
,
847 const XML_Char
*encoding
, int standalone
)
849 /* Do nothing - this function prevents the default handler from
850 being called, thus suppressing the XML declaration from the
855 xml_xinclude_cleanup (void *data_
)
857 struct xinclude_parsing_data
*data
= (struct xinclude_parsing_data
*) data_
;
859 obstack_free (&data
->obstack
, NULL
);
863 const struct gdb_xml_attribute xinclude_attributes
[] = {
864 { "href", GDB_XML_AF_NONE
, NULL
, NULL
},
865 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
868 const struct gdb_xml_element xinclude_elements
[] = {
869 { "http://www.w3.org/2001/XInclude!include", xinclude_attributes
, NULL
,
870 GDB_XML_EF_OPTIONAL
| GDB_XML_EF_REPEATABLE
,
871 xinclude_start_include
, xinclude_end_include
},
872 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
875 /* The main entry point for <xi:include> processing. */
878 xml_process_xincludes (const char *name
, const char *text
,
879 xml_fetch_another fetcher
, void *fetcher_baton
,
882 struct gdb_xml_parser
*parser
;
883 struct xinclude_parsing_data
*data
;
884 struct cleanup
*back_to
;
887 data
= XCNEW (struct xinclude_parsing_data
);
888 obstack_init (&data
->obstack
);
889 back_to
= make_cleanup (xml_xinclude_cleanup
, data
);
891 gdb_xml_create_parser_and_cleanup (name
, xinclude_elements
,
893 parser
->is_xinclude
= 1;
895 data
->include_depth
= depth
;
896 data
->fetcher
= fetcher
;
897 data
->fetcher_baton
= fetcher_baton
;
899 XML_SetCharacterDataHandler (parser
->expat_parser
, NULL
);
900 XML_SetDefaultHandler (parser
->expat_parser
, xml_xinclude_default
);
902 /* Always discard the XML version declarations; the only important
903 thing this provides is encoding, and our result will have been
904 converted to UTF-8. */
905 XML_SetXmlDeclHandler (parser
->expat_parser
, xml_xinclude_xml_decl
);
908 /* Discard the doctype for included documents. */
909 XML_SetDoctypeDeclHandler (parser
->expat_parser
,
910 xml_xinclude_start_doctype
,
911 xml_xinclude_end_doctype
);
913 gdb_xml_use_dtd (parser
, "xinclude.dtd");
915 if (gdb_xml_parse (parser
, text
) == 0)
917 obstack_1grow (&data
->obstack
, '\0');
918 result
= xstrdup ((const char *) obstack_finish (&data
->obstack
));
921 gdb_xml_debug (parser
, _("XInclude processing succeeded."));
926 do_cleanups (back_to
);
929 #endif /* HAVE_LIBEXPAT */
932 /* Return an XML document which was compiled into GDB, from
933 the given FILENAME, or NULL if the file was not compiled in. */
936 fetch_xml_builtin (const char *filename
)
940 for (p
= xml_builtin
; (*p
)[0]; p
++)
941 if (strcmp ((*p
)[0], filename
) == 0)
947 /* A to_xfer_partial helper function which reads XML files which were
948 compiled into GDB. The target may call this function from its own
949 to_xfer_partial handler, after converting object and annex to the
950 appropriate filename. */
953 xml_builtin_xfer_partial (const char *filename
,
954 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
955 ULONGEST offset
, LONGEST len
)
960 gdb_assert (readbuf
!= NULL
&& writebuf
== NULL
);
961 gdb_assert (filename
!= NULL
);
963 buf
= fetch_xml_builtin (filename
);
967 len_avail
= strlen (buf
);
968 if (offset
>= len_avail
)
971 if (len
> len_avail
- offset
)
972 len
= len_avail
- offset
;
973 memcpy (readbuf
, buf
+ offset
, len
);
979 show_debug_xml (struct ui_file
*file
, int from_tty
,
980 struct cmd_list_element
*c
, const char *value
)
982 fprintf_filtered (file
, _("XML debugging is %s.\n"), value
);
986 obstack_xml_printf (struct obstack
*obstack
, const char *format
, ...)
993 va_start (ap
, format
);
996 for (f
= format
; *f
; f
++)
1005 char *a
= va_arg (ap
, char *);
1007 obstack_grow (obstack
, prev
, f
- prev
- 1);
1008 p
= xml_escape_text (a
);
1009 obstack_grow_str (obstack
, p
);
1021 obstack_grow_str (obstack
, prev
);
1026 xml_fetch_content_from_file (const char *filename
, void *baton
)
1028 const char *dirname
= (const char *) baton
;
1030 struct cleanup
*back_to
;
1034 if (dirname
&& *dirname
)
1036 char *fullname
= concat (dirname
, "/", filename
, (char *) NULL
);
1038 if (fullname
== NULL
)
1040 file
= gdb_fopen_cloexec (fullname
, FOPEN_RT
);
1044 file
= gdb_fopen_cloexec (filename
, FOPEN_RT
);
1049 back_to
= make_cleanup_fclose (file
);
1051 /* Read in the whole file, one chunk at a time. */
1054 text
= (char *) xmalloc (len
);
1055 make_cleanup (free_current_contents
, &text
);
1060 /* Continue reading where the last read left off. Leave at least
1061 one byte so that we can NUL-terminate the result. */
1062 bytes_read
= fread (text
+ offset
, 1, len
- offset
- 1, file
);
1065 warning (_("Read error from \"%s\""), filename
);
1066 do_cleanups (back_to
);
1070 offset
+= bytes_read
;
1076 text
= (char *) xrealloc (text
, len
);
1080 discard_cleanups (back_to
);
1082 text
[offset
] = '\0';
1086 void _initialize_xml_support (void);
1089 _initialize_xml_support (void)
1091 add_setshow_boolean_cmd ("xml", class_maintenance
, &debug_xml
,
1092 _("Set XML parser debugging."),
1093 _("Show XML parser debugging."),
1094 _("When set, debugging messages for XML parsers "
1096 NULL
, show_debug_xml
,
1097 &setdebuglist
, &showdebuglist
);