1 /* Helper routines for parsing XML using Expat. 2 3 Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 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. 11 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. 16 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/>. */ 19 20 #include "defs.h" 21 #include "gdbcmd.h" 22 #include "exceptions.h" 23 #include "xml-support.h" 24 25 #include "gdb_string.h" 26 #include "safe-ctype.h" 27 28 /* Debugging flag. */ 29 static int debug_xml; 30 31 /* The contents of this file are only useful if XML support is 32 available. */ 33 #ifdef HAVE_LIBEXPAT 34 35 #include "gdb_expat.h" 36 37 /* The maximum depth of <xi:include> nesting. No need to be miserly, 38 we just want to avoid running out of stack on loops. */ 39 #define MAX_XINCLUDE_DEPTH 30 40 41 /* Simplified XML parser infrastructure. */ 42 43 /* A parsing level -- used to keep track of the current element 44 nesting. */ 45 struct scope_level 46 { 47 /* Elements we allow at this level. */ 48 const struct gdb_xml_element *elements; 49 50 /* The element which we are within. */ 51 const struct gdb_xml_element *element; 52 53 /* Mask of which elements we've seen at this level (used for 54 optional and repeatable checking). */ 55 unsigned int seen; 56 57 /* Body text accumulation. */ 58 struct obstack *body; 59 }; 60 typedef struct scope_level scope_level_s; 61 DEF_VEC_O(scope_level_s); 62 63 /* The parser itself, and our additional state. */ 64 struct gdb_xml_parser 65 { 66 XML_Parser expat_parser; /* The underlying expat parser. */ 67 68 const char *name; /* Name of this parser. */ 69 void *user_data; /* The user's callback data, for handlers. */ 70 71 VEC(scope_level_s) *scopes; /* Scoping stack. */ 72 73 struct gdb_exception error; /* A thrown error, if any. */ 74 int last_line; /* The line of the thrown error, or 0. */ 75 76 const char *dtd_name; /* The name of the expected / default DTD, 77 if specified. */ 78 int is_xinclude; /* Are we the special <xi:include> parser? */ 79 }; 80 81 /* Process some body text. We accumulate the text for later use; it's 82 wrong to do anything with it immediately, because a single block of 83 text might be broken up into multiple calls to this function. */ 84 85 static void 86 gdb_xml_body_text (void *data, const XML_Char *text, int length) 87 { 88 struct gdb_xml_parser *parser = data; 89 struct scope_level *scope = VEC_last (scope_level_s, parser->scopes); 90 91 if (parser->error.reason < 0) 92 return; 93 94 if (scope->body == NULL) 95 { 96 scope->body = XZALLOC (struct obstack); 97 obstack_init (scope->body); 98 } 99 100 obstack_grow (scope->body, text, length); 101 } 102 103 /* Issue a debugging message from one of PARSER's handlers. */ 104 105 void 106 gdb_xml_debug (struct gdb_xml_parser *parser, const char *format, ...) 107 { 108 int line = XML_GetCurrentLineNumber (parser->expat_parser); 109 va_list ap; 110 char *message; 111 112 if (!debug_xml) 113 return; 114 115 va_start (ap, format); 116 message = xstrvprintf (format, ap); 117 if (line) 118 fprintf_unfiltered (gdb_stderr, "%s (line %d): %s\n", 119 parser->name, line, message); 120 else 121 fprintf_unfiltered (gdb_stderr, "%s: %s\n", 122 parser->name, message); 123 xfree (message); 124 } 125 126 /* Issue an error message from one of PARSER's handlers, and stop 127 parsing. */ 128 129 void 130 gdb_xml_error (struct gdb_xml_parser *parser, const char *format, ...) 131 { 132 int line = XML_GetCurrentLineNumber (parser->expat_parser); 133 va_list ap; 134 135 parser->last_line = line; 136 va_start (ap, format); 137 throw_verror (XML_PARSE_ERROR, format, ap); 138 } 139 140 /* Clean up a vector of parsed attribute values. */ 141 142 static void 143 gdb_xml_values_cleanup (void *data) 144 { 145 VEC(gdb_xml_value_s) **values = data; 146 struct gdb_xml_value *value; 147 int ix; 148 149 for (ix = 0; VEC_iterate (gdb_xml_value_s, *values, ix, value); ix++) 150 xfree (value->value); 151 VEC_free (gdb_xml_value_s, *values); 152 } 153 154 /* Handle the start of an element. DATA is our local XML parser, NAME 155 is the element, and ATTRS are the names and values of this 156 element's attributes. */ 157 158 static void 159 gdb_xml_start_element (void *data, const XML_Char *name, 160 const XML_Char **attrs) 161 { 162 struct gdb_xml_parser *parser = data; 163 struct scope_level *scope; 164 struct scope_level new_scope; 165 const struct gdb_xml_element *element; 166 const struct gdb_xml_attribute *attribute; 167 VEC(gdb_xml_value_s) *attributes = NULL; 168 unsigned int seen; 169 struct cleanup *back_to; 170 171 /* Push an error scope. If we return or throw an exception before 172 filling this in, it will tell us to ignore children of this 173 element. */ 174 VEC_reserve (scope_level_s, parser->scopes, 1); 175 scope = VEC_last (scope_level_s, parser->scopes); 176 memset (&new_scope, 0, sizeof (new_scope)); 177 VEC_quick_push (scope_level_s, parser->scopes, &new_scope); 178 179 gdb_xml_debug (parser, _("Entering element <%s>"), name); 180 181 /* Find this element in the list of the current scope's allowed 182 children. Record that we've seen it. */ 183 184 seen = 1; 185 for (element = scope->elements; element && element->name; 186 element++, seen <<= 1) 187 if (strcmp (element->name, name) == 0) 188 break; 189 190 if (element == NULL || element->name == NULL) 191 { 192 /* If we're working on XInclude, <xi:include> can be the child 193 of absolutely anything. Copy the previous scope's element 194 list into the new scope even if there was no match. */ 195 if (parser->is_xinclude) 196 { 197 struct scope_level *unknown_scope; 198 199 XML_DefaultCurrent (parser->expat_parser); 200 201 unknown_scope = VEC_last (scope_level_s, parser->scopes); 202 unknown_scope->elements = scope->elements; 203 return; 204 } 205 206 gdb_xml_debug (parser, _("Element <%s> unknown"), name); 207 return; 208 } 209 210 if (!(element->flags & GDB_XML_EF_REPEATABLE) && (seen & scope->seen)) 211 gdb_xml_error (parser, _("Element <%s> only expected once"), name); 212 213 scope->seen |= seen; 214 215 back_to = make_cleanup (gdb_xml_values_cleanup, &attributes); 216 217 for (attribute = element->attributes; 218 attribute != NULL && attribute->name != NULL; 219 attribute++) 220 { 221 const char *val = NULL; 222 const XML_Char **p; 223 void *parsed_value; 224 struct gdb_xml_value new_value; 225 226 for (p = attrs; *p != NULL; p += 2) 227 if (!strcmp (attribute->name, p[0])) 228 { 229 val = p[1]; 230 break; 231 } 232 233 if (*p != NULL && val == NULL) 234 { 235 gdb_xml_debug (parser, _("Attribute \"%s\" missing a value"), 236 attribute->name); 237 continue; 238 } 239 240 if (*p == NULL && !(attribute->flags & GDB_XML_AF_OPTIONAL)) 241 { 242 gdb_xml_error (parser, _("Required attribute \"%s\" of " 243 "<%s> not specified"), 244 attribute->name, element->name); 245 continue; 246 } 247 248 if (*p == NULL) 249 continue; 250 251 gdb_xml_debug (parser, _("Parsing attribute %s=\"%s\""), 252 attribute->name, val); 253 254 if (attribute->handler) 255 parsed_value = attribute->handler (parser, attribute, val); 256 else 257 parsed_value = xstrdup (val); 258 259 new_value.name = attribute->name; 260 new_value.value = parsed_value; 261 VEC_safe_push (gdb_xml_value_s, attributes, &new_value); 262 } 263 264 /* Check for unrecognized attributes. */ 265 if (debug_xml) 266 { 267 const XML_Char **p; 268 269 for (p = attrs; *p != NULL; p += 2) 270 { 271 for (attribute = element->attributes; 272 attribute != NULL && attribute->name != NULL; 273 attribute++) 274 if (strcmp (attribute->name, *p) == 0) 275 break; 276 277 if (attribute == NULL || attribute->name == NULL) 278 gdb_xml_debug (parser, _("Ignoring unknown attribute %s"), *p); 279 } 280 } 281 282 /* Call the element handler if there is one. */ 283 if (element->start_handler) 284 element->start_handler (parser, element, parser->user_data, attributes); 285 286 /* Fill in a new scope level. */ 287 scope = VEC_last (scope_level_s, parser->scopes); 288 scope->element = element; 289 scope->elements = element->children; 290 291 do_cleanups (back_to); 292 } 293 294 /* Wrapper for gdb_xml_start_element, to prevent throwing exceptions 295 through expat. */ 296 297 static void 298 gdb_xml_start_element_wrapper (void *data, const XML_Char *name, 299 const XML_Char **attrs) 300 { 301 struct gdb_xml_parser *parser = data; 302 volatile struct gdb_exception ex; 303 304 if (parser->error.reason < 0) 305 return; 306 307 TRY_CATCH (ex, RETURN_MASK_ALL) 308 { 309 gdb_xml_start_element (data, name, attrs); 310 } 311 if (ex.reason < 0) 312 { 313 parser->error = ex; 314 #ifdef HAVE_XML_STOPPARSER 315 XML_StopParser (parser->expat_parser, XML_FALSE); 316 #endif 317 } 318 } 319 320 /* Handle the end of an element. DATA is our local XML parser, and 321 NAME is the current element. */ 322 323 static void 324 gdb_xml_end_element (void *data, const XML_Char *name) 325 { 326 struct gdb_xml_parser *parser = data; 327 struct scope_level *scope = VEC_last (scope_level_s, parser->scopes); 328 const struct gdb_xml_element *element; 329 unsigned int seen; 330 331 gdb_xml_debug (parser, _("Leaving element <%s>"), name); 332 333 for (element = scope->elements, seen = 1; 334 element != NULL && element->name != NULL; 335 element++, seen <<= 1) 336 if ((scope->seen & seen) == 0 337 && (element->flags & GDB_XML_EF_OPTIONAL) == 0) 338 gdb_xml_error (parser, _("Required element <%s> is missing"), 339 element->name); 340 341 /* Call the element processor. */ 342 if (scope->element != NULL && scope->element->end_handler) 343 { 344 char *body; 345 346 if (scope->body == NULL) 347 body = ""; 348 else 349 { 350 int length; 351 352 length = obstack_object_size (scope->body); 353 obstack_1grow (scope->body, '\0'); 354 body = obstack_finish (scope->body); 355 356 /* Strip leading and trailing whitespace. */ 357 while (length > 0 && ISSPACE (body[length-1])) 358 body[--length] = '\0'; 359 while (*body && ISSPACE (*body)) 360 body++; 361 } 362 363 scope->element->end_handler (parser, scope->element, parser->user_data, 364 body); 365 } 366 else if (scope->element == NULL) 367 XML_DefaultCurrent (parser->expat_parser); 368 369 /* Pop the scope level. */ 370 if (scope->body) 371 { 372 obstack_free (scope->body, NULL); 373 xfree (scope->body); 374 } 375 VEC_pop (scope_level_s, parser->scopes); 376 } 377 378 /* Wrapper for gdb_xml_end_element, to prevent throwing exceptions 379 through expat. */ 380 381 static void 382 gdb_xml_end_element_wrapper (void *data, const XML_Char *name) 383 { 384 struct gdb_xml_parser *parser = data; 385 volatile struct gdb_exception ex; 386 387 if (parser->error.reason < 0) 388 return; 389 390 TRY_CATCH (ex, RETURN_MASK_ALL) 391 { 392 gdb_xml_end_element (data, name); 393 } 394 if (ex.reason < 0) 395 { 396 parser->error = ex; 397 #ifdef HAVE_XML_STOPPARSER 398 XML_StopParser (parser->expat_parser, XML_FALSE); 399 #endif 400 } 401 } 402 403 /* Free a parser and all its associated state. */ 404 405 static void 406 gdb_xml_cleanup (void *arg) 407 { 408 struct gdb_xml_parser *parser = arg; 409 struct scope_level *scope; 410 int ix; 411 412 XML_ParserFree (parser->expat_parser); 413 414 /* Clean up the scopes. */ 415 for (ix = 0; VEC_iterate (scope_level_s, parser->scopes, ix, scope); ix++) 416 if (scope->body) 417 { 418 obstack_free (scope->body, NULL); 419 xfree (scope->body); 420 } 421 VEC_free (scope_level_s, parser->scopes); 422 423 xfree (parser); 424 } 425 426 /* Initialize and return a parser. Register a cleanup to destroy the 427 parser. */ 428 429 struct gdb_xml_parser * 430 gdb_xml_create_parser_and_cleanup (const char *name, 431 const struct gdb_xml_element *elements, 432 void *user_data) 433 { 434 struct gdb_xml_parser *parser; 435 struct scope_level start_scope; 436 437 /* Initialize the parser. */ 438 parser = XZALLOC (struct gdb_xml_parser); 439 parser->expat_parser = XML_ParserCreateNS (NULL, '!'); 440 if (parser->expat_parser == NULL) 441 { 442 xfree (parser); 443 nomem (0); 444 } 445 446 parser->name = name; 447 448 parser->user_data = user_data; 449 XML_SetUserData (parser->expat_parser, parser); 450 451 /* Set the callbacks. */ 452 XML_SetElementHandler (parser->expat_parser, gdb_xml_start_element_wrapper, 453 gdb_xml_end_element_wrapper); 454 XML_SetCharacterDataHandler (parser->expat_parser, gdb_xml_body_text); 455 456 /* Initialize the outer scope. */ 457 memset (&start_scope, 0, sizeof (start_scope)); 458 start_scope.elements = elements; 459 VEC_safe_push (scope_level_s, parser->scopes, &start_scope); 460 461 make_cleanup (gdb_xml_cleanup, parser); 462 463 return parser; 464 } 465 466 /* External entity handler. The only external entities we support 467 are those compiled into GDB (we do not fetch entities from the 468 target). */ 469 470 static int XMLCALL 471 gdb_xml_fetch_external_entity (XML_Parser expat_parser, 472 const XML_Char *context, 473 const XML_Char *base, 474 const XML_Char *systemId, 475 const XML_Char *publicId) 476 { 477 struct gdb_xml_parser *parser = XML_GetUserData (expat_parser); 478 XML_Parser entity_parser; 479 const char *text; 480 enum XML_Status status; 481 482 if (systemId == NULL) 483 { 484 text = fetch_xml_builtin (parser->dtd_name); 485 if (text == NULL) 486 internal_error (__FILE__, __LINE__, "could not locate built-in DTD %s", 487 parser->dtd_name); 488 } 489 else 490 { 491 text = fetch_xml_builtin (systemId); 492 if (text == NULL) 493 return XML_STATUS_ERROR; 494 } 495 496 entity_parser = XML_ExternalEntityParserCreate (expat_parser, context, NULL); 497 498 /* Don't use our handlers for the contents of the DTD. Just let expat 499 process it. */ 500 XML_SetElementHandler (entity_parser, NULL, NULL); 501 XML_SetDoctypeDeclHandler (entity_parser, NULL, NULL); 502 XML_SetXmlDeclHandler (entity_parser, NULL); 503 XML_SetDefaultHandler (entity_parser, NULL); 504 XML_SetUserData (entity_parser, NULL); 505 506 status = XML_Parse (entity_parser, text, strlen (text), 1); 507 508 XML_ParserFree (entity_parser); 509 return status; 510 } 511 512 /* Associate DTD_NAME, which must be the name of a compiled-in DTD, 513 with PARSER. */ 514 515 void 516 gdb_xml_use_dtd (struct gdb_xml_parser *parser, const char *dtd_name) 517 { 518 enum XML_Error err; 519 520 parser->dtd_name = dtd_name; 521 522 XML_SetParamEntityParsing (parser->expat_parser, 523 XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE); 524 XML_SetExternalEntityRefHandler (parser->expat_parser, 525 gdb_xml_fetch_external_entity); 526 527 /* Even if no DTD is provided, use the built-in DTD anyway. */ 528 err = XML_UseForeignDTD (parser->expat_parser, XML_TRUE); 529 if (err != XML_ERROR_NONE) 530 internal_error (__FILE__, __LINE__, 531 "XML_UseForeignDTD failed: %s", XML_ErrorString (err)); 532 } 533 534 /* Invoke PARSER on BUFFER. BUFFER is the data to parse, which 535 should be NUL-terminated. 536 537 The return value is 0 for success or -1 for error. It may throw, 538 but only if something unexpected goes wrong during parsing; parse 539 errors will be caught, warned about, and reported as failure. */ 540 541 int 542 gdb_xml_parse (struct gdb_xml_parser *parser, const char *buffer) 543 { 544 enum XML_Status status; 545 const char *error_string; 546 547 gdb_xml_debug (parser, _("Starting:\n%s"), buffer); 548 549 status = XML_Parse (parser->expat_parser, buffer, strlen (buffer), 1); 550 551 if (status == XML_STATUS_OK && parser->error.reason == 0) 552 return 0; 553 554 if (parser->error.reason == RETURN_ERROR 555 && parser->error.error == XML_PARSE_ERROR) 556 { 557 gdb_assert (parser->error.message != NULL); 558 error_string = parser->error.message; 559 } 560 else if (status == XML_STATUS_ERROR) 561 { 562 enum XML_Error err = XML_GetErrorCode (parser->expat_parser); 563 564 error_string = XML_ErrorString (err); 565 } 566 else 567 { 568 gdb_assert (parser->error.reason < 0); 569 throw_exception (parser->error); 570 } 571 572 if (parser->last_line != 0) 573 warning (_("while parsing %s (at line %d): %s"), parser->name, 574 parser->last_line, error_string); 575 else 576 warning (_("while parsing %s: %s"), parser->name, error_string); 577 578 return -1; 579 } 580 581 /* Parse a field VALSTR that we expect to contain an integer value. 582 The integer is returned in *VALP. The string is parsed with an 583 equivalent to strtoul. 584 585 Returns 0 for success, -1 for error. */ 586 587 static int 588 xml_parse_unsigned_integer (const char *valstr, ULONGEST *valp) 589 { 590 const char *endptr; 591 ULONGEST result; 592 593 if (*valstr == '\0') 594 return -1; 595 596 result = strtoulst (valstr, &endptr, 0); 597 if (*endptr != '\0') 598 return -1; 599 600 *valp = result; 601 return 0; 602 } 603 604 /* Parse an integer string into a ULONGEST and return it, or call 605 gdb_xml_error if it could not be parsed. */ 606 607 ULONGEST 608 gdb_xml_parse_ulongest (struct gdb_xml_parser *parser, const char *value) 609 { 610 ULONGEST result; 611 612 if (xml_parse_unsigned_integer (value, &result) != 0) 613 gdb_xml_error (parser, _("Can't convert \"%s\" to an integer"), value); 614 615 return result; 616 } 617 618 /* Parse an integer attribute into a ULONGEST. */ 619 620 void * 621 gdb_xml_parse_attr_ulongest (struct gdb_xml_parser *parser, 622 const struct gdb_xml_attribute *attribute, 623 const char *value) 624 { 625 ULONGEST result; 626 void *ret; 627 628 if (xml_parse_unsigned_integer (value, &result) != 0) 629 gdb_xml_error (parser, _("Can't convert %s=\"%s\" to an integer"), 630 attribute->name, value); 631 632 ret = xmalloc (sizeof (result)); 633 memcpy (ret, &result, sizeof (result)); 634 return ret; 635 } 636 637 /* A handler_data for yes/no boolean values. */ 638 639 const struct gdb_xml_enum gdb_xml_enums_boolean[] = { 640 { "yes", 1 }, 641 { "no", 0 }, 642 { NULL, 0 } 643 }; 644 645 /* Map NAME to VALUE. A struct gdb_xml_enum * should be saved as the 646 value of handler_data when using gdb_xml_parse_attr_enum to parse a 647 fixed list of possible strings. The list is terminated by an entry 648 with NAME == NULL. */ 649 650 void * 651 gdb_xml_parse_attr_enum (struct gdb_xml_parser *parser, 652 const struct gdb_xml_attribute *attribute, 653 const char *value) 654 { 655 const struct gdb_xml_enum *enums = attribute->handler_data; 656 void *ret; 657 658 for (enums = attribute->handler_data; enums->name != NULL; enums++) 659 if (strcasecmp (enums->name, value) == 0) 660 break; 661 662 if (enums->name == NULL) 663 gdb_xml_error (parser, _("Unknown attribute value %s=\"%s\""), 664 attribute->name, value); 665 666 ret = xmalloc (sizeof (enums->value)); 667 memcpy (ret, &enums->value, sizeof (enums->value)); 668 return ret; 669 } 670 671 672 /* XInclude processing. This is done as a separate step from actually 673 parsing the document, so that we can produce a single combined XML 674 document - e.g. to hand to a front end or to simplify comparing two 675 documents. We make extensive use of XML_DefaultCurrent, to pass 676 input text directly into the output without reformatting or 677 requoting it. 678 679 We output the DOCTYPE declaration for the first document unchanged, 680 if present, and discard DOCTYPEs from included documents. Only the 681 one we pass through here is used when we feed the result back to 682 expat. The XInclude standard explicitly does not discuss 683 validation of the result; we choose to apply the same DTD applied 684 to the outermost document. 685 686 We can not simply include the external DTD subset in the document 687 as an internal subset, because <!IGNORE> and <!INCLUDE> are valid 688 only in external subsets. But if we do not pass the DTD into the 689 output at all, default values will not be filled in. 690 691 We don't pass through any <?xml> declaration because we generate 692 UTF-8, not whatever the input encoding was. */ 693 694 struct xinclude_parsing_data 695 { 696 /* The obstack to build the output in. */ 697 struct obstack obstack; 698 699 /* A count indicating whether we are in an element whose 700 children should not be copied to the output, and if so, 701 how deep we are nested. This is used for anything inside 702 an xi:include, and for the DTD. */ 703 int skip_depth; 704 705 /* The number of <xi:include> elements currently being processed, 706 to detect loops. */ 707 int include_depth; 708 709 /* A function to call to obtain additional features, and its 710 baton. */ 711 xml_fetch_another fetcher; 712 void *fetcher_baton; 713 }; 714 715 static void 716 xinclude_start_include (struct gdb_xml_parser *parser, 717 const struct gdb_xml_element *element, 718 void *user_data, VEC(gdb_xml_value_s) *attributes) 719 { 720 struct xinclude_parsing_data *data = user_data; 721 char *href = VEC_index (gdb_xml_value_s, attributes, 0)->value; 722 struct cleanup *back_to; 723 char *text, *output; 724 725 gdb_xml_debug (parser, _("Processing XInclude of \"%s\""), href); 726 727 if (data->include_depth > MAX_XINCLUDE_DEPTH) 728 gdb_xml_error (parser, _("Maximum XInclude depth (%d) exceeded"), 729 MAX_XINCLUDE_DEPTH); 730 731 text = data->fetcher (href, data->fetcher_baton); 732 if (text == NULL) 733 gdb_xml_error (parser, _("Could not load XML document \"%s\""), href); 734 back_to = make_cleanup (xfree, text); 735 736 output = xml_process_xincludes (parser->name, text, data->fetcher, 737 data->fetcher_baton, 738 data->include_depth + 1); 739 if (output == NULL) 740 gdb_xml_error (parser, _("Parsing \"%s\" failed"), href); 741 742 obstack_grow (&data->obstack, output, strlen (output)); 743 xfree (output); 744 745 do_cleanups (back_to); 746 747 data->skip_depth++; 748 } 749 750 static void 751 xinclude_end_include (struct gdb_xml_parser *parser, 752 const struct gdb_xml_element *element, 753 void *user_data, const char *body_text) 754 { 755 struct xinclude_parsing_data *data = user_data; 756 757 data->skip_depth--; 758 } 759 760 static void XMLCALL 761 xml_xinclude_default (void *data_, const XML_Char *s, int len) 762 { 763 struct gdb_xml_parser *parser = data_; 764 struct xinclude_parsing_data *data = parser->user_data; 765 766 /* If we are inside of e.g. xi:include or the DTD, don't save this 767 string. */ 768 if (data->skip_depth) 769 return; 770 771 /* Otherwise just add it to the end of the document we're building 772 up. */ 773 obstack_grow (&data->obstack, s, len); 774 } 775 776 static void XMLCALL 777 xml_xinclude_start_doctype (void *data_, const XML_Char *doctypeName, 778 const XML_Char *sysid, const XML_Char *pubid, 779 int has_internal_subset) 780 { 781 struct gdb_xml_parser *parser = data_; 782 struct xinclude_parsing_data *data = parser->user_data; 783 784 /* Don't print out the doctype, or the contents of the DTD internal 785 subset, if any. */ 786 data->skip_depth++; 787 } 788 789 static void XMLCALL 790 xml_xinclude_end_doctype (void *data_) 791 { 792 struct gdb_xml_parser *parser = data_; 793 struct xinclude_parsing_data *data = parser->user_data; 794 795 data->skip_depth--; 796 } 797 798 static void XMLCALL 799 xml_xinclude_xml_decl (void *data_, const XML_Char *version, 800 const XML_Char *encoding, int standalone) 801 { 802 /* Do nothing - this function prevents the default handler from 803 being called, thus suppressing the XML declaration from the 804 output. */ 805 } 806 807 static void 808 xml_xinclude_cleanup (void *data_) 809 { 810 struct xinclude_parsing_data *data = data_; 811 812 obstack_free (&data->obstack, NULL); 813 xfree (data); 814 } 815 816 const struct gdb_xml_attribute xinclude_attributes[] = { 817 { "href", GDB_XML_AF_NONE, NULL, NULL }, 818 { NULL, GDB_XML_AF_NONE, NULL, NULL } 819 }; 820 821 const struct gdb_xml_element xinclude_elements[] = { 822 { "http://www.w3.org/2001/XInclude!include", xinclude_attributes, NULL, 823 GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE, 824 xinclude_start_include, xinclude_end_include }, 825 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 826 }; 827 828 /* The main entry point for <xi:include> processing. */ 829 830 char * 831 xml_process_xincludes (const char *name, const char *text, 832 xml_fetch_another fetcher, void *fetcher_baton, 833 int depth) 834 { 835 struct gdb_xml_parser *parser; 836 struct xinclude_parsing_data *data; 837 struct cleanup *back_to; 838 char *result = NULL; 839 840 data = XZALLOC (struct xinclude_parsing_data); 841 obstack_init (&data->obstack); 842 back_to = make_cleanup (xml_xinclude_cleanup, data); 843 844 parser = gdb_xml_create_parser_and_cleanup (name, xinclude_elements, data); 845 parser->is_xinclude = 1; 846 847 data->include_depth = depth; 848 data->fetcher = fetcher; 849 data->fetcher_baton = fetcher_baton; 850 851 XML_SetCharacterDataHandler (parser->expat_parser, NULL); 852 XML_SetDefaultHandler (parser->expat_parser, xml_xinclude_default); 853 854 /* Always discard the XML version declarations; the only important 855 thing this provides is encoding, and our result will have been 856 converted to UTF-8. */ 857 XML_SetXmlDeclHandler (parser->expat_parser, xml_xinclude_xml_decl); 858 859 if (depth > 0) 860 /* Discard the doctype for included documents. */ 861 XML_SetDoctypeDeclHandler (parser->expat_parser, 862 xml_xinclude_start_doctype, 863 xml_xinclude_end_doctype); 864 865 gdb_xml_use_dtd (parser, "xinclude.dtd"); 866 867 if (gdb_xml_parse (parser, text) == 0) 868 { 869 obstack_1grow (&data->obstack, '\0'); 870 result = xstrdup (obstack_finish (&data->obstack)); 871 872 if (depth == 0) 873 gdb_xml_debug (parser, _("XInclude processing succeeded.")); 874 } 875 else 876 result = NULL; 877 878 do_cleanups (back_to); 879 return result; 880 } 881 #endif /* HAVE_LIBEXPAT */ 882 883 884 /* Return an XML document which was compiled into GDB, from 885 the given FILENAME, or NULL if the file was not compiled in. */ 886 887 const char * 888 fetch_xml_builtin (const char *filename) 889 { 890 const char *(*p)[2]; 891 892 for (p = xml_builtin; (*p)[0]; p++) 893 if (strcmp ((*p)[0], filename) == 0) 894 return (*p)[1]; 895 896 return NULL; 897 } 898 899 /* A to_xfer_partial helper function which reads XML files which were 900 compiled into GDB. The target may call this function from its own 901 to_xfer_partial handler, after converting object and annex to the 902 appropriate filename. */ 903 904 LONGEST 905 xml_builtin_xfer_partial (const char *filename, 906 gdb_byte *readbuf, const gdb_byte *writebuf, 907 ULONGEST offset, LONGEST len) 908 { 909 const char *buf; 910 LONGEST len_avail; 911 912 gdb_assert (readbuf != NULL && writebuf == NULL); 913 gdb_assert (filename != NULL); 914 915 buf = fetch_xml_builtin (filename); 916 if (buf == NULL) 917 return -1; 918 919 len_avail = strlen (buf); 920 if (offset >= len_avail) 921 return 0; 922 923 if (len > len_avail - offset) 924 len = len_avail - offset; 925 memcpy (readbuf, buf + offset, len); 926 return len; 927 } 928 929 930 static void 931 show_debug_xml (struct ui_file *file, int from_tty, 932 struct cmd_list_element *c, const char *value) 933 { 934 fprintf_filtered (file, _("XML debugging is %s.\n"), value); 935 } 936 937 /* Return a malloc allocated string with special characters from TEXT 938 replaced by entity references. */ 939 940 char * 941 xml_escape_text (const char *text) 942 { 943 char *result; 944 int i, special; 945 946 /* Compute the length of the result. */ 947 for (i = 0, special = 0; text[i] != '\0'; i++) 948 switch (text[i]) 949 { 950 case '\'': 951 case '\"': 952 special += 5; 953 break; 954 case '&': 955 special += 4; 956 break; 957 case '<': 958 case '>': 959 special += 3; 960 break; 961 default: 962 break; 963 } 964 965 /* Expand the result. */ 966 result = xmalloc (i + special + 1); 967 for (i = 0, special = 0; text[i] != '\0'; i++) 968 switch (text[i]) 969 { 970 case '\'': 971 strcpy (result + i + special, "'"); 972 special += 5; 973 break; 974 case '\"': 975 strcpy (result + i + special, """); 976 special += 5; 977 break; 978 case '&': 979 strcpy (result + i + special, "&"); 980 special += 4; 981 break; 982 case '<': 983 strcpy (result + i + special, "<"); 984 special += 3; 985 break; 986 case '>': 987 strcpy (result + i + special, ">"); 988 special += 3; 989 break; 990 default: 991 result[i + special] = text[i]; 992 break; 993 } 994 result[i + special] = '\0'; 995 996 return result; 997 } 998 999 void 1000 obstack_xml_printf (struct obstack *obstack, const char *format, ...) 1001 { 1002 va_list ap; 1003 const char *f; 1004 const char *prev; 1005 int percent = 0; 1006 1007 va_start (ap, format); 1008 1009 prev = format; 1010 for (f = format; *f; f++) 1011 { 1012 if (percent) 1013 { 1014 switch (*f) 1015 { 1016 case 's': 1017 { 1018 char *p; 1019 char *a = va_arg (ap, char *); 1020 1021 obstack_grow (obstack, prev, f - prev - 1); 1022 p = xml_escape_text (a); 1023 obstack_grow_str (obstack, p); 1024 xfree (p); 1025 prev = f + 1; 1026 } 1027 break; 1028 } 1029 percent = 0; 1030 } 1031 else if (*f == '%') 1032 percent = 1; 1033 } 1034 1035 obstack_grow_str (obstack, prev); 1036 va_end (ap); 1037 } 1038 1039 char * 1040 xml_fetch_content_from_file (const char *filename, void *baton) 1041 { 1042 const char *dirname = baton; 1043 FILE *file; 1044 struct cleanup *back_to; 1045 char *text; 1046 size_t len, offset; 1047 1048 if (dirname && *dirname) 1049 { 1050 char *fullname = concat (dirname, "/", filename, (char *) NULL); 1051 1052 if (fullname == NULL) 1053 nomem (0); 1054 file = fopen (fullname, FOPEN_RT); 1055 xfree (fullname); 1056 } 1057 else 1058 file = fopen (filename, FOPEN_RT); 1059 1060 if (file == NULL) 1061 return NULL; 1062 1063 back_to = make_cleanup_fclose (file); 1064 1065 /* Read in the whole file, one chunk at a time. */ 1066 len = 4096; 1067 offset = 0; 1068 text = xmalloc (len); 1069 make_cleanup (free_current_contents, &text); 1070 while (1) 1071 { 1072 size_t bytes_read; 1073 1074 /* Continue reading where the last read left off. Leave at least 1075 one byte so that we can NUL-terminate the result. */ 1076 bytes_read = fread (text + offset, 1, len - offset - 1, file); 1077 if (ferror (file)) 1078 { 1079 warning (_("Read error from \"%s\""), filename); 1080 do_cleanups (back_to); 1081 return NULL; 1082 } 1083 1084 offset += bytes_read; 1085 1086 if (feof (file)) 1087 break; 1088 1089 len = len * 2; 1090 text = xrealloc (text, len); 1091 } 1092 1093 fclose (file); 1094 discard_cleanups (back_to); 1095 1096 text[offset] = '\0'; 1097 return text; 1098 } 1099 1100 void _initialize_xml_support (void); 1101 1102 void 1103 _initialize_xml_support (void) 1104 { 1105 add_setshow_boolean_cmd ("xml", class_maintenance, &debug_xml, 1106 _("Set XML parser debugging."), 1107 _("Show XML parser debugging."), 1108 _("When set, debugging messages for XML parsers " 1109 "are displayed."), 1110 NULL, show_debug_xml, 1111 &setdebuglist, &showdebuglist); 1112 } 1113