1 /* Helper routines for parsing XML using Expat.
3 Copyright (C) 2006-2023 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-builtin.h"
23 #include "xml-support.h"
24 #include "gdbsupport/filestuff.h"
25 #include "safe-ctype.h"
30 static bool debug_xml
;
32 /* The contents of this file are only useful if XML support is
36 #include "gdb_expat.h"
38 /* The maximum depth of <xi:include> nesting. No need to be miserly,
39 we just want to avoid running out of stack on loops. */
40 #define MAX_XINCLUDE_DEPTH 30
42 /* Simplified XML parser infrastructure. */
44 /* A parsing level -- used to keep track of the current element
48 explicit scope_level (const gdb_xml_element
*elements_
= NULL
)
49 : elements (elements_
),
54 /* Elements we allow at this level. */
55 const struct gdb_xml_element
*elements
;
57 /* The element which we are within. */
58 const struct gdb_xml_element
*element
;
60 /* Mask of which elements we've seen at this level (used for
61 optional and repeatable checking). */
64 /* Body text accumulation. */
68 /* The parser itself, and our additional state. */
71 gdb_xml_parser (const char *name
,
72 const gdb_xml_element
*elements
,
76 /* Associate DTD_NAME, which must be the name of a compiled-in DTD,
78 void use_dtd (const char *dtd_name
);
80 /* Return the name of the expected / default DTD, if specified. */
81 const char *dtd_name ()
82 { return m_dtd_name
; }
84 /* Invoke the parser on BUFFER. BUFFER is the data to parse, which
85 should be NUL-terminated.
87 The return value is 0 for success or -1 for error. It may throw,
88 but only if something unexpected goes wrong during parsing; parse
89 errors will be caught, warned about, and reported as failure. */
90 int parse (const char *buffer
);
92 /* Issue a debugging message. */
93 void vdebug (const char *format
, va_list ap
)
94 ATTRIBUTE_PRINTF (2, 0);
96 /* Issue an error message, and stop parsing. */
97 void verror (const char *format
, va_list ap
)
98 ATTRIBUTE_NORETURN
ATTRIBUTE_PRINTF (2, 0);
100 void body_text (const XML_Char
*text
, int length
);
101 void start_element (const XML_Char
*name
, const XML_Char
**attrs
);
102 void end_element (const XML_Char
*name
);
104 /* Return the name of this parser. */
108 /* Return the user's callback data, for handlers. */
110 { return m_user_data
; };
112 /* Are we the special <xi:include> parser? */
113 void set_is_xinclude (bool is_xinclude
)
114 { m_is_xinclude
= is_xinclude
; }
116 /* A thrown error, if any. */
117 void set_error (gdb_exception
&&error
)
119 m_error
= std::move (error
);
120 #ifdef HAVE_XML_STOPPARSER
121 XML_StopParser (m_expat_parser
, XML_FALSE
);
125 /* Return the underlying expat parser. */
126 XML_Parser
expat_parser ()
127 { return m_expat_parser
; }
130 /* The underlying expat parser. */
131 XML_Parser m_expat_parser
;
133 /* Name of this parser. */
136 /* The user's callback data, for handlers. */
140 std::vector
<scope_level
> m_scopes
;
142 /* A thrown error, if any. */
143 struct gdb_exception m_error
;
145 /* The line of the thrown error, or 0. */
148 /* The name of the expected / default DTD, if specified. */
149 const char *m_dtd_name
;
151 /* Are we the special <xi:include> parser? */
155 /* Process some body text. We accumulate the text for later use; it's
156 wrong to do anything with it immediately, because a single block of
157 text might be broken up into multiple calls to this function. */
160 gdb_xml_parser::body_text (const XML_Char
*text
, int length
)
162 if (m_error
.reason
< 0)
165 scope_level
&scope
= m_scopes
.back ();
166 scope
.body
.append (text
, length
);
170 gdb_xml_body_text (void *data
, const XML_Char
*text
, int length
)
172 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
174 parser
->body_text (text
, length
);
177 /* Issue a debugging message from one of PARSER's handlers. */
180 gdb_xml_parser::vdebug (const char *format
, va_list ap
)
182 int line
= XML_GetCurrentLineNumber (m_expat_parser
);
184 std::string message
= string_vprintf (format
, ap
);
186 gdb_printf (gdb_stderr
, "%s (line %d): %s\n",
187 m_name
, line
, message
.c_str ());
189 gdb_printf (gdb_stderr
, "%s: %s\n",
190 m_name
, message
.c_str ());
194 gdb_xml_debug (struct gdb_xml_parser
*parser
, const char *format
, ...)
200 va_start (ap
, format
);
201 parser
->vdebug (format
, ap
);
205 /* Issue an error message from one of PARSER's handlers, and stop
209 gdb_xml_parser::verror (const char *format
, va_list ap
)
211 int line
= XML_GetCurrentLineNumber (m_expat_parser
);
214 throw_verror (XML_PARSE_ERROR
, format
, ap
);
218 gdb_xml_error (struct gdb_xml_parser
*parser
, const char *format
, ...)
221 va_start (ap
, format
);
222 parser
->verror (format
, ap
);
226 /* Find the attribute named NAME in the set of parsed attributes
227 ATTRIBUTES. Returns NULL if not found. */
229 struct gdb_xml_value
*
230 xml_find_attribute (std::vector
<gdb_xml_value
> &attributes
,
233 for (gdb_xml_value
&value
: attributes
)
234 if (strcmp (value
.name
, name
) == 0)
240 /* Handle the start of an element. NAME is the element, and ATTRS are
241 the names and values of this element's attributes. */
244 gdb_xml_parser::start_element (const XML_Char
*name
,
245 const XML_Char
**attrs
)
247 if (m_error
.reason
< 0)
250 const struct gdb_xml_element
*element
;
251 const struct gdb_xml_attribute
*attribute
;
254 /* Push an error scope. If we return or throw an exception before
255 filling this in, it will tell us to ignore children of this
256 element. Note we don't take a reference to the element yet
257 because further below we'll process the element which may recurse
258 back here and push more elements to the vector. When the
259 recursion unrolls all such elements will have been popped back
260 already, but if one of those pushes reallocates the vector,
261 previous element references will be invalidated. */
262 m_scopes
.emplace_back ();
264 /* Get a reference to the current scope. */
265 scope_level
&scope
= m_scopes
[m_scopes
.size () - 2];
267 gdb_xml_debug (this, _("Entering element <%s>"), name
);
269 /* Find this element in the list of the current scope's allowed
270 children. Record that we've seen it. */
273 for (element
= scope
.elements
; element
&& element
->name
;
274 element
++, seen
<<= 1)
275 if (strcmp (element
->name
, name
) == 0)
278 if (element
== NULL
|| element
->name
== NULL
)
280 /* If we're working on XInclude, <xi:include> can be the child
281 of absolutely anything. Copy the previous scope's element
282 list into the new scope even if there was no match. */
285 XML_DefaultCurrent (m_expat_parser
);
287 scope_level
&unknown_scope
= m_scopes
.back ();
288 unknown_scope
.elements
= scope
.elements
;
292 gdb_xml_debug (this, _("Element <%s> unknown"), name
);
296 if (!(element
->flags
& GDB_XML_EF_REPEATABLE
) && (seen
& scope
.seen
))
297 gdb_xml_error (this, _("Element <%s> only expected once"), name
);
301 std::vector
<gdb_xml_value
> attributes
;
303 for (attribute
= element
->attributes
;
304 attribute
!= NULL
&& attribute
->name
!= NULL
;
307 const char *val
= NULL
;
311 for (p
= attrs
; *p
!= NULL
; p
+= 2)
312 if (!strcmp (attribute
->name
, p
[0]))
318 if (*p
!= NULL
&& val
== NULL
)
320 gdb_xml_debug (this, _("Attribute \"%s\" missing a value"),
325 if (*p
== NULL
&& !(attribute
->flags
& GDB_XML_AF_OPTIONAL
))
327 gdb_xml_error (this, _("Required attribute \"%s\" of "
328 "<%s> not specified"),
329 attribute
->name
, element
->name
);
336 gdb_xml_debug (this, _("Parsing attribute %s=\"%s\""),
337 attribute
->name
, val
);
339 if (attribute
->handler
)
340 parsed_value
= attribute
->handler (this, attribute
, val
);
342 parsed_value
= xstrdup (val
);
344 attributes
.emplace_back (attribute
->name
, parsed_value
);
347 /* Check for unrecognized attributes. */
352 for (p
= attrs
; *p
!= NULL
; p
+= 2)
354 for (attribute
= element
->attributes
;
355 attribute
!= NULL
&& attribute
->name
!= NULL
;
357 if (strcmp (attribute
->name
, *p
) == 0)
360 if (attribute
== NULL
|| attribute
->name
== NULL
)
361 gdb_xml_debug (this, _("Ignoring unknown attribute %s"), *p
);
365 /* Call the element handler if there is one. */
366 if (element
->start_handler
)
367 element
->start_handler (this, element
, m_user_data
, attributes
);
369 /* Fill in a new scope level. Note that we must delay getting a
370 back reference till here because above we might have recursed,
371 which may have reallocated the vector which invalidates
372 iterators/pointers/references. */
373 scope_level
&new_scope
= m_scopes
.back ();
374 new_scope
.element
= element
;
375 new_scope
.elements
= element
->children
;
378 /* Wrapper for gdb_xml_start_element, to prevent throwing exceptions
382 gdb_xml_start_element_wrapper (void *data
, const XML_Char
*name
,
383 const XML_Char
**attrs
)
385 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
389 parser
->start_element (name
, attrs
);
391 catch (gdb_exception
&ex
)
393 parser
->set_error (std::move (ex
));
397 /* Handle the end of an element. NAME is the current element. */
400 gdb_xml_parser::end_element (const XML_Char
*name
)
402 if (m_error
.reason
< 0)
405 struct scope_level
*scope
= &m_scopes
.back ();
406 const struct gdb_xml_element
*element
;
409 gdb_xml_debug (this, _("Leaving element <%s>"), name
);
411 for (element
= scope
->elements
, seen
= 1;
412 element
!= NULL
&& element
->name
!= NULL
;
413 element
++, seen
<<= 1)
414 if ((scope
->seen
& seen
) == 0
415 && (element
->flags
& GDB_XML_EF_OPTIONAL
) == 0)
416 gdb_xml_error (this, _("Required element <%s> is missing"),
419 /* Call the element processor. */
420 if (scope
->element
!= NULL
&& scope
->element
->end_handler
)
424 if (scope
->body
.empty ())
430 length
= scope
->body
.size ();
431 body
= scope
->body
.c_str ();
433 /* Strip leading and trailing whitespace. */
434 while (length
> 0 && ISSPACE (body
[length
- 1]))
436 scope
->body
.erase (length
);
437 while (*body
&& ISSPACE (*body
))
441 scope
->element
->end_handler (this, scope
->element
,
444 else if (scope
->element
== NULL
)
445 XML_DefaultCurrent (m_expat_parser
);
447 /* Pop the scope level. */
448 m_scopes
.pop_back ();
451 /* Wrapper for gdb_xml_end_element, to prevent throwing exceptions
455 gdb_xml_end_element_wrapper (void *data
, const XML_Char
*name
)
457 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data
;
461 parser
->end_element (name
);
463 catch (gdb_exception
&ex
)
465 parser
->set_error (std::move (ex
));
469 /* Free a parser and all its associated state. */
471 gdb_xml_parser::~gdb_xml_parser ()
473 XML_ParserFree (m_expat_parser
);
476 /* Initialize a parser. */
478 gdb_xml_parser::gdb_xml_parser (const char *name
,
479 const gdb_xml_element
*elements
,
482 m_user_data (user_data
),
485 m_is_xinclude (false)
487 m_expat_parser
= XML_ParserCreateNS (NULL
, '!');
488 if (m_expat_parser
== NULL
)
491 XML_SetUserData (m_expat_parser
, this);
493 /* Set the callbacks. */
494 XML_SetElementHandler (m_expat_parser
, gdb_xml_start_element_wrapper
,
495 gdb_xml_end_element_wrapper
);
496 XML_SetCharacterDataHandler (m_expat_parser
, gdb_xml_body_text
);
498 /* Initialize the outer scope. */
499 m_scopes
.emplace_back (elements
);
502 /* External entity handler. The only external entities we support
503 are those compiled into GDB (we do not fetch entities from the
507 gdb_xml_fetch_external_entity (XML_Parser expat_parser
,
508 const XML_Char
*context
,
509 const XML_Char
*base
,
510 const XML_Char
*systemId
,
511 const XML_Char
*publicId
)
513 XML_Parser entity_parser
;
515 enum XML_Status status
;
517 if (systemId
== NULL
)
519 gdb_xml_parser
*parser
520 = (gdb_xml_parser
*) XML_GetUserData (expat_parser
);
522 text
= fetch_xml_builtin (parser
->dtd_name ());
524 internal_error (_("could not locate built-in DTD %s"),
525 parser
->dtd_name ());
529 text
= fetch_xml_builtin (systemId
);
531 return XML_STATUS_ERROR
;
534 entity_parser
= XML_ExternalEntityParserCreate (expat_parser
,
537 /* Don't use our handlers for the contents of the DTD. Just let expat
539 XML_SetElementHandler (entity_parser
, NULL
, NULL
);
540 XML_SetDoctypeDeclHandler (entity_parser
, NULL
, NULL
);
541 XML_SetXmlDeclHandler (entity_parser
, NULL
);
542 XML_SetDefaultHandler (entity_parser
, NULL
);
543 XML_SetUserData (entity_parser
, NULL
);
545 status
= XML_Parse (entity_parser
, text
, strlen (text
), 1);
547 XML_ParserFree (entity_parser
);
552 gdb_xml_parser::use_dtd (const char *dtd_name
)
556 m_dtd_name
= dtd_name
;
558 XML_SetParamEntityParsing (m_expat_parser
,
559 XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE
);
560 XML_SetExternalEntityRefHandler (m_expat_parser
,
561 gdb_xml_fetch_external_entity
);
563 /* Even if no DTD is provided, use the built-in DTD anyway. */
564 err
= XML_UseForeignDTD (m_expat_parser
, XML_TRUE
);
565 if (err
!= XML_ERROR_NONE
)
566 internal_error (_("XML_UseForeignDTD failed: %s"),
567 XML_ErrorString (err
));
570 /* Invoke PARSER on BUFFER. BUFFER is the data to parse, which
571 should be NUL-terminated.
573 The return value is 0 for success or -1 for error. It may throw,
574 but only if something unexpected goes wrong during parsing; parse
575 errors will be caught, warned about, and reported as failure. */
578 gdb_xml_parser::parse (const char *buffer
)
580 enum XML_Status status
;
581 const char *error_string
;
583 gdb_xml_debug (this, _("Starting:\n%s"), buffer
);
585 status
= XML_Parse (m_expat_parser
, buffer
, strlen (buffer
), 1);
587 if (status
== XML_STATUS_OK
&& m_error
.reason
== 0)
590 if (m_error
.reason
== RETURN_ERROR
591 && m_error
.error
== XML_PARSE_ERROR
)
593 gdb_assert (m_error
.message
!= NULL
);
594 error_string
= m_error
.what ();
596 else if (status
== XML_STATUS_ERROR
)
598 enum XML_Error err
= XML_GetErrorCode (m_expat_parser
);
600 error_string
= XML_ErrorString (err
);
604 gdb_assert (m_error
.reason
< 0);
605 throw_exception (std::move (m_error
));
608 if (m_last_line
!= 0)
609 warning (_("while parsing %s (at line %d): %s"), m_name
,
610 m_last_line
, error_string
);
612 warning (_("while parsing %s: %s"), m_name
, error_string
);
618 gdb_xml_parse_quick (const char *name
, const char *dtd_name
,
619 const struct gdb_xml_element
*elements
,
620 const char *document
, void *user_data
)
622 gdb_xml_parser
parser (name
, elements
, user_data
);
623 if (dtd_name
!= NULL
)
624 parser
.use_dtd (dtd_name
);
625 return parser
.parse (document
);
628 /* Parse a field VALSTR that we expect to contain an integer value.
629 The integer is returned in *VALP. The string is parsed with an
630 equivalent to strtoul.
632 Returns 0 for success, -1 for error. */
635 xml_parse_unsigned_integer (const char *valstr
, ULONGEST
*valp
)
643 result
= strtoulst (valstr
, &endptr
, 0);
651 /* Parse an integer string into a ULONGEST and return it, or call
652 gdb_xml_error if it could not be parsed. */
655 gdb_xml_parse_ulongest (struct gdb_xml_parser
*parser
, const char *value
)
659 if (xml_parse_unsigned_integer (value
, &result
) != 0)
660 gdb_xml_error (parser
, _("Can't convert \"%s\" to an integer"), value
);
665 /* Parse an integer attribute into a ULONGEST. */
668 gdb_xml_parse_attr_ulongest (struct gdb_xml_parser
*parser
,
669 const struct gdb_xml_attribute
*attribute
,
675 if (xml_parse_unsigned_integer (value
, &result
) != 0)
676 gdb_xml_error (parser
, _("Can't convert %s=\"%s\" to an integer"),
677 attribute
->name
, value
);
679 ret
= XNEW (ULONGEST
);
680 memcpy (ret
, &result
, sizeof (result
));
684 /* A handler_data for yes/no boolean values. */
686 const struct gdb_xml_enum gdb_xml_enums_boolean
[] = {
692 /* Map NAME to VALUE. A struct gdb_xml_enum * should be saved as the
693 value of handler_data when using gdb_xml_parse_attr_enum to parse a
694 fixed list of possible strings. The list is terminated by an entry
695 with NAME == NULL. */
698 gdb_xml_parse_attr_enum (struct gdb_xml_parser
*parser
,
699 const struct gdb_xml_attribute
*attribute
,
702 const struct gdb_xml_enum
*enums
703 = (const struct gdb_xml_enum
*) attribute
->handler_data
;
706 for (enums
= (const struct gdb_xml_enum
*) attribute
->handler_data
;
707 enums
->name
!= NULL
; enums
++)
708 if (strcasecmp (enums
->name
, value
) == 0)
711 if (enums
->name
== NULL
)
712 gdb_xml_error (parser
, _("Unknown attribute value %s=\"%s\""),
713 attribute
->name
, value
);
715 ret
= xmalloc (sizeof (enums
->value
));
716 memcpy (ret
, &enums
->value
, sizeof (enums
->value
));
721 /* XInclude processing. This is done as a separate step from actually
722 parsing the document, so that we can produce a single combined XML
723 document - e.g. to hand to a front end or to simplify comparing two
724 documents. We make extensive use of XML_DefaultCurrent, to pass
725 input text directly into the output without reformatting or
728 We output the DOCTYPE declaration for the first document unchanged,
729 if present, and discard DOCTYPEs from included documents. Only the
730 one we pass through here is used when we feed the result back to
731 expat. The XInclude standard explicitly does not discuss
732 validation of the result; we choose to apply the same DTD applied
733 to the outermost document.
735 We can not simply include the external DTD subset in the document
736 as an internal subset, because <!IGNORE> and <!INCLUDE> are valid
737 only in external subsets. But if we do not pass the DTD into the
738 output at all, default values will not be filled in.
740 We don't pass through any <?xml> declaration because we generate
741 UTF-8, not whatever the input encoding was. */
743 struct xinclude_parsing_data
745 xinclude_parsing_data (std::string
&output_
,
746 xml_fetch_another fetcher_
,
750 include_depth (include_depth_
),
754 /* Where the output goes. */
757 /* A count indicating whether we are in an element whose
758 children should not be copied to the output, and if so,
759 how deep we are nested. This is used for anything inside
760 an xi:include, and for the DTD. */
763 /* The number of <xi:include> elements currently being processed,
767 /* A function to call to obtain additional features, and its
769 xml_fetch_another fetcher
;
773 xinclude_start_include (struct gdb_xml_parser
*parser
,
774 const struct gdb_xml_element
*element
,
776 std::vector
<gdb_xml_value
> &attributes
)
778 struct xinclude_parsing_data
*data
779 = (struct xinclude_parsing_data
*) user_data
;
780 char *href
= (char *) xml_find_attribute (attributes
, "href")->value
.get ();
782 gdb_xml_debug (parser
, _("Processing XInclude of \"%s\""), href
);
784 if (data
->include_depth
> MAX_XINCLUDE_DEPTH
)
785 gdb_xml_error (parser
, _("Maximum XInclude depth (%d) exceeded"),
788 gdb::optional
<gdb::char_vector
> text
= data
->fetcher (href
);
790 gdb_xml_error (parser
, _("Could not load XML document \"%s\""), href
);
792 if (!xml_process_xincludes (data
->output
, parser
->name (),
793 text
->data (), data
->fetcher
,
794 data
->include_depth
+ 1))
795 gdb_xml_error (parser
, _("Parsing \"%s\" failed"), href
);
801 xinclude_end_include (struct gdb_xml_parser
*parser
,
802 const struct gdb_xml_element
*element
,
803 void *user_data
, const char *body_text
)
805 struct xinclude_parsing_data
*data
806 = (struct xinclude_parsing_data
*) user_data
;
812 xml_xinclude_default (void *data_
, const XML_Char
*s
, int len
)
814 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data_
;
815 xinclude_parsing_data
*data
= (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 data
->output
.append (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 xinclude_parsing_data
*data
= (xinclude_parsing_data
*) parser
->user_data ();
835 /* Don't print out the doctype, or the contents of the DTD internal
841 xml_xinclude_end_doctype (void *data_
)
843 struct gdb_xml_parser
*parser
= (struct gdb_xml_parser
*) data_
;
844 xinclude_parsing_data
*data
= (xinclude_parsing_data
*) parser
->user_data ();
850 xml_xinclude_xml_decl (void *data_
, const XML_Char
*version
,
851 const XML_Char
*encoding
, int standalone
)
853 /* Do nothing - this function prevents the default handler from
854 being called, thus suppressing the XML declaration from the
858 const struct gdb_xml_attribute xinclude_attributes
[] = {
859 { "href", GDB_XML_AF_NONE
, NULL
, NULL
},
860 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
863 const struct gdb_xml_element xinclude_elements
[] = {
864 { "http://www.w3.org/2001/XInclude!include", xinclude_attributes
, NULL
,
865 GDB_XML_EF_OPTIONAL
| GDB_XML_EF_REPEATABLE
,
866 xinclude_start_include
, xinclude_end_include
},
867 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
870 /* The main entry point for <xi:include> processing. */
873 xml_process_xincludes (std::string
&result
,
874 const char *name
, const char *text
,
875 xml_fetch_another fetcher
, int depth
)
877 xinclude_parsing_data
data (result
, fetcher
, depth
);
879 gdb_xml_parser
parser (name
, xinclude_elements
, &data
);
880 parser
.set_is_xinclude (true);
882 XML_SetCharacterDataHandler (parser
.expat_parser (), NULL
);
883 XML_SetDefaultHandler (parser
.expat_parser (), xml_xinclude_default
);
885 /* Always discard the XML version declarations; the only important
886 thing this provides is encoding, and our result will have been
887 converted to UTF-8. */
888 XML_SetXmlDeclHandler (parser
.expat_parser (), xml_xinclude_xml_decl
);
891 /* Discard the doctype for included documents. */
892 XML_SetDoctypeDeclHandler (parser
.expat_parser (),
893 xml_xinclude_start_doctype
,
894 xml_xinclude_end_doctype
);
896 parser
.use_dtd ("xinclude.dtd");
898 if (parser
.parse (text
) == 0)
901 gdb_xml_debug (&parser
, _("XInclude processing succeeded."));
907 #endif /* HAVE_LIBEXPAT */
910 /* Return an XML document which was compiled into GDB, from
911 the given FILENAME, or NULL if the file was not compiled in. */
914 fetch_xml_builtin (const char *filename
)
916 const char *const (*p
)[2];
918 for (p
= xml_builtin
; (*p
)[0]; p
++)
919 if (strcmp ((*p
)[0], filename
) == 0)
925 /* A to_xfer_partial helper function which reads XML files which were
926 compiled into GDB. The target may call this function from its own
927 to_xfer_partial handler, after converting object and annex to the
928 appropriate filename. */
931 xml_builtin_xfer_partial (const char *filename
,
932 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
933 ULONGEST offset
, LONGEST len
)
938 gdb_assert (readbuf
!= NULL
&& writebuf
== NULL
);
939 gdb_assert (filename
!= NULL
);
941 buf
= fetch_xml_builtin (filename
);
945 len_avail
= strlen (buf
);
946 if (offset
>= len_avail
)
949 if (len
> len_avail
- offset
)
950 len
= len_avail
- offset
;
951 memcpy (readbuf
, buf
+ offset
, len
);
957 show_debug_xml (struct ui_file
*file
, int from_tty
,
958 struct cmd_list_element
*c
, const char *value
)
960 gdb_printf (file
, _("XML debugging is %s.\n"), value
);
963 gdb::optional
<gdb::char_vector
>
964 xml_fetch_content_from_file (const char *filename
, const char *dirname
)
968 if (dirname
!= nullptr && *dirname
!= '\0')
970 gdb::unique_xmalloc_ptr
<char> fullname
971 (concat (dirname
, "/", filename
, (char *) NULL
));
973 file
= gdb_fopen_cloexec (fullname
.get (), FOPEN_RB
);
976 file
= gdb_fopen_cloexec (filename
, FOPEN_RB
);
981 /* Read in the whole file. */
985 if (fseek (file
.get (), 0, SEEK_END
) == -1)
986 perror_with_name (_("seek to end of file"));
987 len
= ftell (file
.get ());
988 rewind (file
.get ());
990 gdb::char_vector
text (len
+ 1);
992 if (fread (text
.data (), 1, len
, file
.get ()) != len
993 || ferror (file
.get ()))
995 warning (_("Read error from \"%s\""), filename
);
1003 void _initialize_xml_support ();
1004 void _initialize_xml_support ();
1006 _initialize_xml_support ()
1008 add_setshow_boolean_cmd ("xml", class_maintenance
, &debug_xml
,
1009 _("Set XML parser debugging."),
1010 _("Show XML parser debugging."),
1011 _("When set, debugging messages for XML parsers "
1013 NULL
, show_debug_xml
,
1014 &setdebuglist
, &showdebuglist
);