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"
30 /* The contents of this file are only useful if XML support is
34 #include "gdb_expat.h"
36 /* The maximum depth of <xi:include> nesting. No need to be miserly,
37 we just want to avoid running out of stack on loops. */
38 #define MAX_XINCLUDE_DEPTH 30
40 /* Simplified XML parser infrastructure. */
42 /* A parsing level -- used to keep track of the current element
46 explicit scope_level (const gdb_xml_element
*elements_
= NULL
)
47 : elements (elements_
),
53 scope_level (scope_level
&&other
) noexcept
54 : elements (other
.elements
),
55 element (other
.element
),
67 obstack_free (this->body
, NULL
);
72 /* Elements we allow at this level. */
73 const struct gdb_xml_element
*elements
;
75 /* The element which we are within. */
76 const struct gdb_xml_element
*element
;
78 /* Mask of which elements we've seen at this level (used for
79 optional and repeatable checking). */
82 /* Body text accumulation. This is an owning pointer. */
86 /* The parser itself, and our additional state. */
89 gdb_xml_parser (const char *name
,
90 const gdb_xml_element
*elements
,
94 XML_Parser expat_parser
; /* The underlying expat parser. */
96 const char *name
; /* Name of this parser. */
97 void *user_data
; /* The user's callback data, for handlers. */
100 std::vector
<scope_level
> scopes
;
102 struct gdb_exception error
; /* A thrown error, if any. */
103 int last_line
; /* The line of the thrown error, or 0. */
105 const char *dtd_name
; /* The name of the expected / default DTD,
107 bool is_xinclude
; /* Are we the special <xi:include> parser? */
110 /* Process some body text. We accumulate the text for later use; it's
111 wrong to do anything with it immediately, because a single block of
112 text might be broken up into multiple calls to this function. */
115 gdb_xml_body_text (void *data
, const XML_Char
*text
, int length
)
117 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
119 if (parser
->error
.reason
< 0)
122 scope_level
&scope
= parser
->scopes
.back ();
124 if (scope
.body
== NULL
)
126 scope
.body
= XCNEW (struct obstack
);
127 obstack_init (scope
.body
);
130 obstack_grow (scope
.body
, text
, length
);
133 /* Issue a debugging message from one of PARSER's handlers. */
136 gdb_xml_debug (struct gdb_xml_parser
*parser
, const char *format
, ...)
138 int line
= XML_GetCurrentLineNumber (parser
->expat_parser
);
145 va_start (ap
, format
);
146 message
= xstrvprintf (format
, ap
);
148 fprintf_unfiltered (gdb_stderr
, "%s (line %d): %s\n",
149 parser
->name
, line
, message
);
151 fprintf_unfiltered (gdb_stderr
, "%s: %s\n",
152 parser
->name
, message
);
156 /* Issue an error message from one of PARSER's handlers, and stop
160 gdb_xml_error (struct gdb_xml_parser
*parser
, const char *format
, ...)
162 int line
= XML_GetCurrentLineNumber (parser
->expat_parser
);
165 parser
->last_line
= line
;
166 va_start (ap
, format
);
167 throw_verror (XML_PARSE_ERROR
, format
, ap
);
170 /* Find the attribute named NAME in the set of parsed attributes
171 ATTRIBUTES. Returns NULL if not found. */
173 struct gdb_xml_value
*
174 xml_find_attribute (VEC(gdb_xml_value_s
) *attributes
, const char *name
)
176 struct gdb_xml_value
*value
;
179 for (ix
= 0; VEC_iterate (gdb_xml_value_s
, attributes
, ix
, value
); ix
++)
180 if (strcmp (value
->name
, name
) == 0)
186 /* Clean up a vector of parsed attribute values. */
189 gdb_xml_values_cleanup (void *data
)
191 VEC(gdb_xml_value_s
) **values
= (VEC(gdb_xml_value_s
) **) data
;
192 struct gdb_xml_value
*value
;
195 for (ix
= 0; VEC_iterate (gdb_xml_value_s
, *values
, ix
, value
); ix
++)
196 xfree (value
->value
);
197 VEC_free (gdb_xml_value_s
, *values
);
200 /* Handle the start of an element. DATA is our local XML parser, NAME
201 is the element, and ATTRS are the names and values of this
202 element's attributes. */
205 gdb_xml_start_element (void *data
, const XML_Char
*name
,
206 const XML_Char
**attrs
)
208 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
209 const struct gdb_xml_element
*element
;
210 const struct gdb_xml_attribute
*attribute
;
211 VEC(gdb_xml_value_s
) *attributes
= NULL
;
213 struct cleanup
*back_to
;
215 /* Push an error scope. If we return or throw an exception before
216 filling this in, it will tell us to ignore children of this
217 element. Note we don't take a reference to the element yet
218 because further below we'll process the element which may recurse
219 back here and push more elements to the vector. When the
220 recursion unrolls all such elements will have been popped back
221 already, but if one of those pushes reallocates the vector,
222 previous element references will be invalidated. */
223 parser
->scopes
.emplace_back ();
225 /* Get a reference to the current scope. */
226 scope_level
&scope
= parser
->scopes
[parser
->scopes
.size () - 2];
228 gdb_xml_debug (parser
, _("Entering element <%s>"), name
);
230 /* Find this element in the list of the current scope's allowed
231 children. Record that we've seen it. */
234 for (element
= scope
.elements
; element
&& element
->name
;
235 element
++, seen
<<= 1)
236 if (strcmp (element
->name
, name
) == 0)
239 if (element
== NULL
|| element
->name
== NULL
)
241 /* If we're working on XInclude, <xi:include> can be the child
242 of absolutely anything. Copy the previous scope's element
243 list into the new scope even if there was no match. */
244 if (parser
->is_xinclude
)
246 XML_DefaultCurrent (parser
->expat_parser
);
248 scope_level
&unknown_scope
= parser
->scopes
.back ();
249 unknown_scope
.elements
= scope
.elements
;
253 gdb_xml_debug (parser
, _("Element <%s> unknown"), name
);
257 if (!(element
->flags
& GDB_XML_EF_REPEATABLE
) && (seen
& scope
.seen
))
258 gdb_xml_error (parser
, _("Element <%s> only expected once"), name
);
262 back_to
= make_cleanup (gdb_xml_values_cleanup
, &attributes
);
264 for (attribute
= element
->attributes
;
265 attribute
!= NULL
&& attribute
->name
!= NULL
;
268 const char *val
= NULL
;
271 struct gdb_xml_value new_value
;
273 for (p
= attrs
; *p
!= NULL
; p
+= 2)
274 if (!strcmp (attribute
->name
, p
[0]))
280 if (*p
!= NULL
&& val
== NULL
)
282 gdb_xml_debug (parser
, _("Attribute \"%s\" missing a value"),
287 if (*p
== NULL
&& !(attribute
->flags
& GDB_XML_AF_OPTIONAL
))
289 gdb_xml_error (parser
, _("Required attribute \"%s\" of "
290 "<%s> not specified"),
291 attribute
->name
, element
->name
);
298 gdb_xml_debug (parser
, _("Parsing attribute %s=\"%s\""),
299 attribute
->name
, val
);
301 if (attribute
->handler
)
302 parsed_value
= attribute
->handler (parser
, attribute
, val
);
304 parsed_value
= xstrdup (val
);
306 new_value
.name
= attribute
->name
;
307 new_value
.value
= parsed_value
;
308 VEC_safe_push (gdb_xml_value_s
, attributes
, &new_value
);
311 /* Check for unrecognized attributes. */
316 for (p
= attrs
; *p
!= NULL
; p
+= 2)
318 for (attribute
= element
->attributes
;
319 attribute
!= NULL
&& attribute
->name
!= NULL
;
321 if (strcmp (attribute
->name
, *p
) == 0)
324 if (attribute
== NULL
|| attribute
->name
== NULL
)
325 gdb_xml_debug (parser
, _("Ignoring unknown attribute %s"), *p
);
329 /* Call the element handler if there is one. */
330 if (element
->start_handler
)
331 element
->start_handler (parser
, element
, parser
->user_data
, attributes
);
333 /* Fill in a new scope level. Note that we must delay getting a
334 back reference till here because above we might have recursed,
335 which may have reallocated the vector which invalidates
336 iterators/pointers/references. */
337 scope_level
&new_scope
= parser
->scopes
.back ();
338 new_scope
.element
= element
;
339 new_scope
.elements
= element
->children
;
341 do_cleanups (back_to
);
344 /* Wrapper for gdb_xml_start_element, to prevent throwing exceptions
348 gdb_xml_start_element_wrapper (void *data
, const XML_Char
*name
,
349 const XML_Char
**attrs
)
351 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
353 if (parser
->error
.reason
< 0)
358 gdb_xml_start_element (data
, name
, attrs
);
360 CATCH (ex
, RETURN_MASK_ALL
)
363 #ifdef HAVE_XML_STOPPARSER
364 XML_StopParser (parser
->expat_parser
, XML_FALSE
);
370 /* Handle the end of an element. PARSER is our local XML parser, and
371 NAME is the current element. */
374 gdb_xml_end_element (gdb_xml_parser
*parser
, const XML_Char
*name
)
376 struct scope_level
*scope
= &parser
->scopes
.back ();
377 const struct gdb_xml_element
*element
;
380 gdb_xml_debug (parser
, _("Leaving element <%s>"), name
);
382 for (element
= scope
->elements
, seen
= 1;
383 element
!= NULL
&& element
->name
!= NULL
;
384 element
++, seen
<<= 1)
385 if ((scope
->seen
& seen
) == 0
386 && (element
->flags
& GDB_XML_EF_OPTIONAL
) == 0)
387 gdb_xml_error (parser
, _("Required element <%s> is missing"),
390 /* Call the element processor. */
391 if (scope
->element
!= NULL
&& scope
->element
->end_handler
)
393 const char *scope_body
;
395 if (scope
->body
== NULL
)
401 length
= obstack_object_size (scope
->body
);
402 obstack_1grow (scope
->body
, '\0');
403 char *body
= (char *) obstack_finish (scope
->body
);
405 /* Strip leading and trailing whitespace. */
406 while (length
> 0 && ISSPACE (body
[length
-1]))
407 body
[--length
] = '\0';
408 while (*body
&& ISSPACE (*body
))
414 scope
->element
->end_handler (parser
, scope
->element
, parser
->user_data
,
417 else if (scope
->element
== NULL
)
418 XML_DefaultCurrent (parser
->expat_parser
);
420 /* Pop the scope level. */
421 parser
->scopes
.pop_back ();
424 /* Wrapper for gdb_xml_end_element, to prevent throwing exceptions
428 gdb_xml_end_element_wrapper (void *data
, const XML_Char
*name
)
430 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
432 if (parser
->error
.reason
< 0)
437 gdb_xml_end_element (parser
, name
);
439 CATCH (ex
, RETURN_MASK_ALL
)
442 #ifdef HAVE_XML_STOPPARSER
443 XML_StopParser (parser
->expat_parser
, XML_FALSE
);
449 /* Free a parser and all its associated state. */
451 gdb_xml_parser::~gdb_xml_parser ()
453 XML_ParserFree (this->expat_parser
);
456 /* Initialize a parser. */
458 gdb_xml_parser::gdb_xml_parser (const char *name_
,
459 const gdb_xml_element
*elements
,
462 user_data (user_data_
),
463 error (exception_none
),
468 this->expat_parser
= XML_ParserCreateNS (NULL
, '!');
469 if (this->expat_parser
== NULL
)
472 XML_SetUserData (this->expat_parser
, this);
474 /* Set the callbacks. */
475 XML_SetElementHandler (this->expat_parser
, gdb_xml_start_element_wrapper
,
476 gdb_xml_end_element_wrapper
);
477 XML_SetCharacterDataHandler (this->expat_parser
, gdb_xml_body_text
);
479 /* Initialize the outer scope. */
480 this->scopes
.emplace_back (elements
);
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 gdb_xml_parser
parser (name
, elements
, user_data
);
607 if (dtd_name
!= NULL
)
608 gdb_xml_use_dtd (&parser
, dtd_name
);
609 return gdb_xml_parse (&parser
, document
);
612 /* Parse a field VALSTR that we expect to contain an integer value.
613 The integer is returned in *VALP. The string is parsed with an
614 equivalent to strtoul.
616 Returns 0 for success, -1 for error. */
619 xml_parse_unsigned_integer (const char *valstr
, ULONGEST
*valp
)
627 result
= strtoulst (valstr
, &endptr
, 0);
635 /* Parse an integer string into a ULONGEST and return it, or call
636 gdb_xml_error if it could not be parsed. */
639 gdb_xml_parse_ulongest (struct gdb_xml_parser
*parser
, const char *value
)
643 if (xml_parse_unsigned_integer (value
, &result
) != 0)
644 gdb_xml_error (parser
, _("Can't convert \"%s\" to an integer"), value
);
649 /* Parse an integer attribute into a ULONGEST. */
652 gdb_xml_parse_attr_ulongest (struct gdb_xml_parser
*parser
,
653 const struct gdb_xml_attribute
*attribute
,
659 if (xml_parse_unsigned_integer (value
, &result
) != 0)
660 gdb_xml_error (parser
, _("Can't convert %s=\"%s\" to an integer"),
661 attribute
->name
, value
);
663 ret
= XNEW (ULONGEST
);
664 memcpy (ret
, &result
, sizeof (result
));
668 /* A handler_data for yes/no boolean values. */
670 const struct gdb_xml_enum gdb_xml_enums_boolean
[] = {
676 /* Map NAME to VALUE. A struct gdb_xml_enum * should be saved as the
677 value of handler_data when using gdb_xml_parse_attr_enum to parse a
678 fixed list of possible strings. The list is terminated by an entry
679 with NAME == NULL. */
682 gdb_xml_parse_attr_enum (struct gdb_xml_parser
*parser
,
683 const struct gdb_xml_attribute
*attribute
,
686 const struct gdb_xml_enum
*enums
687 = (const struct gdb_xml_enum
*) attribute
->handler_data
;
690 for (enums
= (const struct gdb_xml_enum
*) attribute
->handler_data
;
691 enums
->name
!= NULL
; enums
++)
692 if (strcasecmp (enums
->name
, value
) == 0)
695 if (enums
->name
== NULL
)
696 gdb_xml_error (parser
, _("Unknown attribute value %s=\"%s\""),
697 attribute
->name
, value
);
699 ret
= xmalloc (sizeof (enums
->value
));
700 memcpy (ret
, &enums
->value
, sizeof (enums
->value
));
705 /* XInclude processing. This is done as a separate step from actually
706 parsing the document, so that we can produce a single combined XML
707 document - e.g. to hand to a front end or to simplify comparing two
708 documents. We make extensive use of XML_DefaultCurrent, to pass
709 input text directly into the output without reformatting or
712 We output the DOCTYPE declaration for the first document unchanged,
713 if present, and discard DOCTYPEs from included documents. Only the
714 one we pass through here is used when we feed the result back to
715 expat. The XInclude standard explicitly does not discuss
716 validation of the result; we choose to apply the same DTD applied
717 to the outermost document.
719 We can not simply include the external DTD subset in the document
720 as an internal subset, because <!IGNORE> and <!INCLUDE> are valid
721 only in external subsets. But if we do not pass the DTD into the
722 output at all, default values will not be filled in.
724 We don't pass through any <?xml> declaration because we generate
725 UTF-8, not whatever the input encoding was. */
727 struct xinclude_parsing_data
729 xinclude_parsing_data (xml_fetch_another fetcher_
, void *fetcher_baton_
,
732 include_depth (include_depth_
),
734 fetcher_baton (fetcher_baton_
)
736 obstack_init (&this->obstack
);
739 ~xinclude_parsing_data ()
741 obstack_free (&this->obstack
, NULL
);
744 /* The obstack to build the output in. */
745 struct obstack obstack
;
747 /* A count indicating whether we are in an element whose
748 children should not be copied to the output, and if so,
749 how deep we are nested. This is used for anything inside
750 an xi:include, and for the DTD. */
753 /* The number of <xi:include> elements currently being processed,
757 /* A function to call to obtain additional features, and its
759 xml_fetch_another fetcher
;
764 xinclude_start_include (struct gdb_xml_parser
*parser
,
765 const struct gdb_xml_element
*element
,
766 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
768 struct xinclude_parsing_data
*data
769 = (struct xinclude_parsing_data
*) user_data
;
770 char *href
= (char *) xml_find_attribute (attributes
, "href")->value
;
771 struct cleanup
*back_to
;
774 gdb_xml_debug (parser
, _("Processing XInclude of \"%s\""), href
);
776 if (data
->include_depth
> MAX_XINCLUDE_DEPTH
)
777 gdb_xml_error (parser
, _("Maximum XInclude depth (%d) exceeded"),
780 text
= data
->fetcher (href
, data
->fetcher_baton
);
782 gdb_xml_error (parser
, _("Could not load XML document \"%s\""), href
);
783 back_to
= make_cleanup (xfree
, text
);
785 output
= xml_process_xincludes (parser
->name
, text
, data
->fetcher
,
787 data
->include_depth
+ 1);
789 gdb_xml_error (parser
, _("Parsing \"%s\" failed"), href
);
791 obstack_grow (&data
->obstack
, output
, strlen (output
));
794 do_cleanups (back_to
);
800 xinclude_end_include (struct gdb_xml_parser
*parser
,
801 const struct gdb_xml_element
*element
,
802 void *user_data
, const char *body_text
)
804 struct xinclude_parsing_data
*data
805 = (struct xinclude_parsing_data
*) user_data
;
811 xml_xinclude_default (void *data_
, const XML_Char
*s
, int len
)
813 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data_
;
814 struct xinclude_parsing_data
*data
815 = (struct xinclude_parsing_data
*) parser
->user_data
;
817 /* If we are inside of e.g. xi:include or the DTD, don't save this
819 if (data
->skip_depth
)
822 /* Otherwise just add it to the end of the document we're building
824 obstack_grow (&data
->obstack
, s
, len
);
828 xml_xinclude_start_doctype (void *data_
, const XML_Char
*doctypeName
,
829 const XML_Char
*sysid
, const XML_Char
*pubid
,
830 int has_internal_subset
)
832 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data_
;
833 struct xinclude_parsing_data
*data
834 = (struct xinclude_parsing_data
*) parser
->user_data
;
836 /* Don't print out the doctype, or the contents of the DTD internal
842 xml_xinclude_end_doctype (void *data_
)
844 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data_
;
845 struct xinclude_parsing_data
*data
846 = (struct xinclude_parsing_data
*) parser
->user_data
;
852 xml_xinclude_xml_decl (void *data_
, const XML_Char
*version
,
853 const XML_Char
*encoding
, int standalone
)
855 /* Do nothing - this function prevents the default handler from
856 being called, thus suppressing the XML declaration from the
860 const struct gdb_xml_attribute xinclude_attributes
[] = {
861 { "href", GDB_XML_AF_NONE
, NULL
, NULL
},
862 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
865 const struct gdb_xml_element xinclude_elements
[] = {
866 { "http://www.w3.org/2001/XInclude!include", xinclude_attributes
, NULL
,
867 GDB_XML_EF_OPTIONAL
| GDB_XML_EF_REPEATABLE
,
868 xinclude_start_include
, xinclude_end_include
},
869 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
872 /* The main entry point for <xi:include> processing. */
875 xml_process_xincludes (const char *name
, const char *text
,
876 xml_fetch_another fetcher
, void *fetcher_baton
,
881 xinclude_parsing_data
data (fetcher
, fetcher_baton
, depth
);
883 gdb_xml_parser
parser (name
, xinclude_elements
, &data
);
884 parser
.is_xinclude
= true;
886 XML_SetCharacterDataHandler (parser
.expat_parser
, NULL
);
887 XML_SetDefaultHandler (parser
.expat_parser
, xml_xinclude_default
);
889 /* Always discard the XML version declarations; the only important
890 thing this provides is encoding, and our result will have been
891 converted to UTF-8. */
892 XML_SetXmlDeclHandler (parser
.expat_parser
, xml_xinclude_xml_decl
);
895 /* Discard the doctype for included documents. */
896 XML_SetDoctypeDeclHandler (parser
.expat_parser
,
897 xml_xinclude_start_doctype
,
898 xml_xinclude_end_doctype
);
900 gdb_xml_use_dtd (&parser
, "xinclude.dtd");
902 if (gdb_xml_parse (&parser
, text
) == 0)
904 obstack_1grow (&data
.obstack
, '\0');
905 result
= xstrdup ((const char *) obstack_finish (&data
.obstack
));
908 gdb_xml_debug (&parser
, _("XInclude processing succeeded."));
915 #endif /* HAVE_LIBEXPAT */
918 /* Return an XML document which was compiled into GDB, from
919 the given FILENAME, or NULL if the file was not compiled in. */
922 fetch_xml_builtin (const char *filename
)
926 for (p
= xml_builtin
; (*p
)[0]; p
++)
927 if (strcmp ((*p
)[0], filename
) == 0)
933 /* A to_xfer_partial helper function which reads XML files which were
934 compiled into GDB. The target may call this function from its own
935 to_xfer_partial handler, after converting object and annex to the
936 appropriate filename. */
939 xml_builtin_xfer_partial (const char *filename
,
940 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
941 ULONGEST offset
, LONGEST len
)
946 gdb_assert (readbuf
!= NULL
&& writebuf
== NULL
);
947 gdb_assert (filename
!= NULL
);
949 buf
= fetch_xml_builtin (filename
);
953 len_avail
= strlen (buf
);
954 if (offset
>= len_avail
)
957 if (len
> len_avail
- offset
)
958 len
= len_avail
- offset
;
959 memcpy (readbuf
, buf
+ offset
, len
);
965 show_debug_xml (struct ui_file
*file
, int from_tty
,
966 struct cmd_list_element
*c
, const char *value
)
968 fprintf_filtered (file
, _("XML debugging is %s.\n"), value
);
972 obstack_xml_printf (struct obstack
*obstack
, const char *format
, ...)
979 va_start (ap
, format
);
982 for (f
= format
; *f
; f
++)
991 char *a
= va_arg (ap
, char *);
993 obstack_grow (obstack
, prev
, f
- prev
- 1);
994 p
= xml_escape_text (a
);
995 obstack_grow_str (obstack
, p
);
1007 obstack_grow_str (obstack
, prev
);
1012 xml_fetch_content_from_file (const char *filename
, void *baton
)
1014 const char *dirname
= (const char *) baton
;
1016 struct cleanup
*back_to
;
1020 if (dirname
&& *dirname
)
1022 char *fullname
= concat (dirname
, "/", filename
, (char *) NULL
);
1024 if (fullname
== NULL
)
1026 file
= gdb_fopen_cloexec (fullname
, FOPEN_RT
);
1030 file
= gdb_fopen_cloexec (filename
, FOPEN_RT
);
1035 back_to
= make_cleanup_fclose (file
);
1037 /* Read in the whole file, one chunk at a time. */
1040 text
= (char *) xmalloc (len
);
1041 make_cleanup (free_current_contents
, &text
);
1046 /* Continue reading where the last read left off. Leave at least
1047 one byte so that we can NUL-terminate the result. */
1048 bytes_read
= fread (text
+ offset
, 1, len
- offset
- 1, file
);
1051 warning (_("Read error from \"%s\""), filename
);
1052 do_cleanups (back_to
);
1056 offset
+= bytes_read
;
1062 text
= (char *) xrealloc (text
, len
);
1066 discard_cleanups (back_to
);
1068 text
[offset
] = '\0';
1072 void _initialize_xml_support (void);
1075 _initialize_xml_support (void)
1077 add_setshow_boolean_cmd ("xml", class_maintenance
, &debug_xml
,
1078 _("Set XML parser debugging."),
1079 _("Show XML parser debugging."),
1080 _("When set, debugging messages for XML parsers "
1082 NULL
, show_debug_xml
,
1083 &setdebuglist
, &showdebuglist
);